2006-03-02 14:06:52 -05:00
|
|
|
/*
|
2011-06-19 00:24:06 -04:00
|
|
|
* be_local.c : backend for the local database
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2011-01-05 23:45:15 -05:00
|
|
|
* Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2006-03-02 14:06:52 -05:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2007-12-10 23:55:22 -05:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2006-03-02 14:06:52 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2009-11-14 14:26:37 -05:00
|
|
|
#include <stdint.h> /* intmax_t */
|
2006-03-02 14:06:52 -05:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <limits.h> /* PATH_MAX */
|
2007-03-05 17:13:33 -05:00
|
|
|
|
|
|
|
/* libalpm */
|
|
|
|
#include "db.h"
|
|
|
|
#include "alpm_list.h"
|
2006-03-02 14:06:52 -05:00
|
|
|
#include "log.h"
|
|
|
|
#include "util.h"
|
|
|
|
#include "alpm.h"
|
2006-10-15 15:31:03 -04:00
|
|
|
#include "handle.h"
|
2006-11-20 04:10:23 -05:00
|
|
|
#include "package.h"
|
2007-11-13 00:01:14 -05:00
|
|
|
#include "deps.h"
|
2006-10-15 15:31:03 -04:00
|
|
|
|
2011-06-28 23:02:58 -04:00
|
|
|
static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq);
|
|
|
|
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
#define LAZY_LOAD(info, errret) \
|
|
|
|
do { \
|
2011-06-28 23:02:58 -04:00
|
|
|
if(!(pkg->infolevel & info)) { \
|
|
|
|
local_db_read(pkg, info); \
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
} \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
|
|
|
|
/* Cache-specific accessor functions. These implementations allow for lazy
|
|
|
|
* loading by the files backend when a data member is actually needed
|
|
|
|
* rather than loading all pieces of information when the package is first
|
|
|
|
* initialized.
|
|
|
|
*/
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static const char *_cache_get_desc(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->desc;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static const char *_cache_get_url(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->url;
|
|
|
|
}
|
|
|
|
|
2011-09-07 11:21:47 -04:00
|
|
|
static alpm_time_t _cache_get_builddate(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, 0);
|
|
|
|
return pkg->builddate;
|
|
|
|
}
|
|
|
|
|
2011-09-07 11:21:47 -04:00
|
|
|
static alpm_time_t _cache_get_installdate(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, 0);
|
|
|
|
return pkg->installdate;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static const char *_cache_get_packager(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->packager;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static const char *_cache_get_arch(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->arch;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static off_t _cache_get_isize(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, -1);
|
|
|
|
return pkg->isize;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_pkgreason_t _cache_get_reason(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, -1);
|
|
|
|
return pkg->reason;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_licenses(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->licenses;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_groups(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->groups;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static int _cache_has_scriptlet(alpm_pkg_t *pkg)
|
2010-12-13 22:00:23 -05:00
|
|
|
{
|
2011-06-28 23:02:58 -04:00
|
|
|
LAZY_LOAD(INFRQ_SCRIPTLET, NULL);
|
2010-12-13 22:00:23 -05:00
|
|
|
return pkg->scriptlet;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_depends(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2010-10-30 01:35:43 -04:00
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
return pkg->depends;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_optdepends(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2010-10-30 01:35:43 -04:00
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
return pkg->optdepends;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_conflicts(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2010-10-30 01:35:43 -04:00
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
return pkg->conflicts;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_provides(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2010-10-30 01:35:43 -04:00
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
return pkg->provides;
|
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_replaces(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
|
|
|
LAZY_LOAD(INFRQ_DESC, NULL);
|
|
|
|
return pkg->replaces;
|
|
|
|
}
|
|
|
|
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
static alpm_filelist_t *_cache_get_files(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2011-06-28 23:02:58 -04:00
|
|
|
LAZY_LOAD(INFRQ_FILES, NULL);
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
return &(pkg->files);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
static alpm_list_t *_cache_get_backup(alpm_pkg_t *pkg)
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
{
|
2011-06-28 23:02:58 -04:00
|
|
|
LAZY_LOAD(INFRQ_FILES, NULL);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
return pkg->backup;
|
|
|
|
}
|
|
|
|
|
2008-05-11 17:49:01 -04:00
|
|
|
/**
|
|
|
|
* Open a package changelog for reading. Similar to fopen in functionality,
|
|
|
|
* except that the returned 'file stream' is from the database.
|
|
|
|
* @param pkg the package (from db) to read the changelog
|
|
|
|
* @return a 'file stream' to the package changelog
|
|
|
|
*/
|
2011-06-28 09:26:39 -04:00
|
|
|
static void *_cache_changelog_open(alpm_pkg_t *pkg)
|
2008-05-11 17:49:01 -04:00
|
|
|
{
|
2011-08-18 00:25:19 -04:00
|
|
|
alpm_db_t *db = alpm_pkg_get_db(pkg);
|
2011-09-30 12:08:49 -04:00
|
|
|
char *clfile = _alpm_local_db_pkgpath(db, pkg, "changelog");
|
|
|
|
FILE *f = fopen(clfile, "r");
|
|
|
|
free(clfile);
|
|
|
|
return f;
|
2008-05-11 17:49:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Read data from an open changelog 'file stream'. Similar to fread in
|
|
|
|
* functionality, this function takes a buffer and amount of data to read.
|
|
|
|
* @param ptr a buffer to fill with raw changelog data
|
|
|
|
* @param size the size of the buffer
|
|
|
|
* @param pkg the package that the changelog is being read from
|
|
|
|
* @param fp a 'file stream' to the package changelog
|
|
|
|
* @return the number of characters read, or 0 if there is no more data
|
|
|
|
*/
|
2010-12-18 09:15:05 -05:00
|
|
|
static size_t _cache_changelog_read(void *ptr, size_t size,
|
2011-09-18 18:07:05 -04:00
|
|
|
const alpm_pkg_t UNUSED *pkg, void *fp)
|
2008-05-11 17:49:01 -04:00
|
|
|
{
|
2011-03-20 20:45:57 -04:00
|
|
|
return fread(ptr, 1, size, (FILE *)fp);
|
2008-05-11 17:49:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Close a package changelog for reading. Similar to fclose in functionality,
|
|
|
|
* except that the 'file stream' is from the database.
|
|
|
|
* @param pkg the package that the changelog was read from
|
|
|
|
* @param fp a 'file stream' to the package changelog
|
|
|
|
* @return whether closing the package changelog stream was successful
|
|
|
|
*/
|
2011-06-28 09:26:39 -04:00
|
|
|
static int _cache_changelog_close(const alpm_pkg_t UNUSED *pkg, void *fp)
|
2008-05-11 17:49:01 -04:00
|
|
|
{
|
2011-03-20 20:45:57 -04:00
|
|
|
return fclose((FILE *)fp);
|
2008-05-11 17:49:01 -04:00
|
|
|
}
|
|
|
|
|
2011-06-28 23:02:58 -04:00
|
|
|
static int _cache_force_load(alpm_pkg_t *pkg)
|
|
|
|
{
|
|
|
|
return local_db_read(pkg, INFRQ_ALL);
|
|
|
|
}
|
|
|
|
|
2010-10-14 00:09:20 -04:00
|
|
|
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
/** The local database operations struct. Get package fields through
|
|
|
|
* lazy accessor methods that handle any backend loading and caching
|
|
|
|
* logic.
|
|
|
|
*/
|
|
|
|
static struct pkg_operations local_pkg_ops = {
|
|
|
|
.get_desc = _cache_get_desc,
|
|
|
|
.get_url = _cache_get_url,
|
|
|
|
.get_builddate = _cache_get_builddate,
|
|
|
|
.get_installdate = _cache_get_installdate,
|
|
|
|
.get_packager = _cache_get_packager,
|
|
|
|
.get_arch = _cache_get_arch,
|
|
|
|
.get_isize = _cache_get_isize,
|
|
|
|
.get_reason = _cache_get_reason,
|
2010-12-13 22:00:23 -05:00
|
|
|
.has_scriptlet = _cache_has_scriptlet,
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
.get_licenses = _cache_get_licenses,
|
|
|
|
.get_groups = _cache_get_groups,
|
|
|
|
.get_depends = _cache_get_depends,
|
|
|
|
.get_optdepends = _cache_get_optdepends,
|
|
|
|
.get_conflicts = _cache_get_conflicts,
|
|
|
|
.get_provides = _cache_get_provides,
|
|
|
|
.get_replaces = _cache_get_replaces,
|
|
|
|
.get_files = _cache_get_files,
|
|
|
|
.get_backup = _cache_get_backup,
|
2008-05-11 17:49:01 -04:00
|
|
|
|
|
|
|
.changelog_open = _cache_changelog_open,
|
|
|
|
.changelog_read = _cache_changelog_read,
|
|
|
|
.changelog_close = _cache_changelog_close,
|
2011-06-28 23:02:58 -04:00
|
|
|
|
|
|
|
.force_load = _cache_force_load,
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
};
|
|
|
|
|
2011-06-28 00:11:43 -04:00
|
|
|
static int checkdbdir(alpm_db_t *db)
|
2010-10-10 23:47:18 -04:00
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
const char *path = _alpm_db_path(db);
|
|
|
|
|
|
|
|
if(stat(path, &buf) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
|
2010-10-10 23:47:18 -04:00
|
|
|
path);
|
|
|
|
if(_alpm_makepath(path) != 0) {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
|
2010-10-10 23:47:18 -04:00
|
|
|
}
|
|
|
|
} else if(!S_ISDIR(buf.st_mode)) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_WARNING, _("removing invalid database: %s\n"), path);
|
2010-10-10 23:47:18 -04:00
|
|
|
if(unlink(path) != 0 || _alpm_makepath(path) != 0) {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
|
2010-10-10 23:47:18 -04:00
|
|
|
}
|
|
|
|
}
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2010-10-10 23:47:18 -04:00
|
|
|
}
|
2009-10-09 13:11:27 -04:00
|
|
|
|
2010-10-05 12:44:32 -04:00
|
|
|
static int is_dir(const char *path, struct dirent *entry)
|
|
|
|
{
|
2010-11-16 21:13:36 -05:00
|
|
|
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
|
2011-03-01 14:39:43 -05:00
|
|
|
if(entry->d_type != DT_UNKNOWN) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return (entry->d_type == DT_DIR);
|
2011-03-01 14:39:43 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
char buffer[PATH_MAX];
|
|
|
|
struct stat sbuf;
|
|
|
|
|
|
|
|
snprintf(buffer, PATH_MAX, "%s/%s", path, entry->d_name);
|
|
|
|
|
2011-04-20 20:45:16 -04:00
|
|
|
if(!stat(buffer, &sbuf)) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return S_ISDIR(sbuf.st_mode);
|
2011-03-01 14:39:43 -05:00
|
|
|
}
|
2010-10-05 12:44:32 -04:00
|
|
|
}
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2010-10-05 12:44:32 -04:00
|
|
|
}
|
|
|
|
|
2011-06-28 00:11:43 -04:00
|
|
|
static int local_db_validate(alpm_db_t *db)
|
2011-04-20 20:54:01 -04:00
|
|
|
{
|
|
|
|
struct dirent *ent = NULL;
|
|
|
|
const char *dbpath;
|
|
|
|
DIR *dbdir;
|
|
|
|
int ret = -1;
|
|
|
|
|
2011-06-07 21:42:15 -04:00
|
|
|
if(db->status & DB_STATUS_VALID) {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-08-17 22:06:04 -04:00
|
|
|
if(db->status & DB_STATUS_INVALID) {
|
|
|
|
return -1;
|
|
|
|
}
|
2011-06-07 21:42:15 -04:00
|
|
|
|
2011-04-20 20:54:01 -04:00
|
|
|
dbpath = _alpm_db_path(db);
|
|
|
|
if(dbpath == NULL) {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
|
2011-04-20 20:54:01 -04:00
|
|
|
}
|
|
|
|
dbdir = opendir(dbpath);
|
|
|
|
if(dbdir == NULL) {
|
|
|
|
if(errno == ENOENT) {
|
|
|
|
/* database dir doesn't exist yet */
|
2011-06-07 21:42:15 -04:00
|
|
|
db->status |= DB_STATUS_VALID;
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status &= ~DB_STATUS_INVALID;
|
|
|
|
db->status &= ~DB_STATUS_EXISTS;
|
|
|
|
db->status |= DB_STATUS_MISSING;
|
2011-04-20 20:54:01 -04:00
|
|
|
return 0;
|
|
|
|
} else {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
|
2011-04-20 20:54:01 -04:00
|
|
|
}
|
|
|
|
}
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status |= DB_STATUS_EXISTS;
|
|
|
|
db->status &= ~DB_STATUS_MISSING;
|
2011-04-20 20:54:01 -04:00
|
|
|
|
|
|
|
while((ent = readdir(dbdir)) != NULL) {
|
|
|
|
const char *name = ent->d_name;
|
|
|
|
char path[PATH_MAX];
|
|
|
|
|
|
|
|
if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(!is_dir(dbpath, ent)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
|
|
|
|
if(access(path, F_OK) == 0) {
|
|
|
|
/* we found a depends file- bail */
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status &= ~DB_STATUS_VALID;
|
|
|
|
db->status |= DB_STATUS_INVALID;
|
2011-07-01 12:01:39 -04:00
|
|
|
db->handle->pm_errno = ALPM_ERR_DB_VERSION;
|
2011-04-20 20:54:01 -04:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* we found no depends file after full scan */
|
2011-06-07 21:42:15 -04:00
|
|
|
db->status |= DB_STATUS_VALID;
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status &= ~DB_STATUS_INVALID;
|
2011-04-20 20:54:01 -04:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
done:
|
|
|
|
if(dbdir) {
|
|
|
|
closedir(dbdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-28 00:11:43 -04:00
|
|
|
static int local_db_populate(alpm_db_t *db)
|
2006-03-02 14:06:52 -05:00
|
|
|
{
|
2011-02-15 17:56:44 -05:00
|
|
|
size_t est_count;
|
|
|
|
int count = 0;
|
2011-01-24 18:48:54 -05:00
|
|
|
struct stat buf;
|
2006-03-02 14:06:52 -05:00
|
|
|
struct dirent *ent = NULL;
|
2009-09-14 23:44:51 -04:00
|
|
|
const char *dbpath;
|
2009-01-19 14:45:12 -05:00
|
|
|
DIR *dbdir;
|
2006-03-02 14:06:52 -05:00
|
|
|
|
2011-08-17 22:06:04 -04:00
|
|
|
if(db->status & DB_STATUS_INVALID) {
|
|
|
|
RET_ERR(db->handle, ALPM_ERR_DB_INVALID, -1);
|
|
|
|
}
|
|
|
|
/* note: DB_STATUS_MISSING is not fatal for local database */
|
|
|
|
|
2009-09-14 23:44:51 -04:00
|
|
|
dbpath = _alpm_db_path(db);
|
2010-10-20 02:59:34 -04:00
|
|
|
if(dbpath == NULL) {
|
2011-05-02 17:25:47 -04:00
|
|
|
/* pm_errno set in _alpm_db_path() */
|
|
|
|
return -1;
|
2010-10-20 02:59:34 -04:00
|
|
|
}
|
2011-04-20 20:54:01 -04:00
|
|
|
|
2009-09-14 23:44:51 -04:00
|
|
|
dbdir = opendir(dbpath);
|
2009-01-19 14:45:12 -05:00
|
|
|
if(dbdir == NULL) {
|
2011-02-15 17:56:44 -05:00
|
|
|
if(errno == ENOENT) {
|
|
|
|
/* no database existing yet is not an error */
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status &= ~DB_STATUS_EXISTS;
|
|
|
|
db->status |= DB_STATUS_MISSING;
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2011-02-15 17:56:44 -05:00
|
|
|
}
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
|
2009-01-19 14:45:12 -05:00
|
|
|
}
|
2011-01-24 18:48:54 -05:00
|
|
|
if(fstat(dirfd(dbdir), &buf) != 0) {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
|
2011-02-15 17:56:44 -05:00
|
|
|
}
|
2011-08-17 22:06:04 -04:00
|
|
|
db->status |= DB_STATUS_EXISTS;
|
|
|
|
db->status &= ~DB_STATUS_MISSING;
|
2011-02-15 17:56:44 -05:00
|
|
|
if(buf.st_nlink >= 2) {
|
|
|
|
est_count = buf.st_nlink;
|
|
|
|
} else {
|
|
|
|
/* Some filesystems don't subscribe to the two-implicit links school of
|
|
|
|
* thought, e.g. BTRFS, HFS+. See
|
|
|
|
* http://kerneltrap.org/mailarchive/linux-btrfs/2010/1/23/6723483/thread
|
|
|
|
*/
|
|
|
|
est_count = 0;
|
2011-04-02 14:26:27 -04:00
|
|
|
while(readdir(dbdir) != NULL) {
|
2011-02-15 17:56:44 -05:00
|
|
|
est_count++;
|
|
|
|
}
|
|
|
|
rewinddir(dbdir);
|
|
|
|
}
|
|
|
|
if(est_count >= 2) {
|
|
|
|
/* subtract the two extra pointers to get # of children */
|
|
|
|
est_count -= 2;
|
2011-01-24 18:48:54 -05:00
|
|
|
}
|
2011-01-24 20:49:34 -05:00
|
|
|
|
2012-01-02 14:29:40 -05:00
|
|
|
db->pkgcache = _alpm_pkghash_create(est_count);
|
2011-02-07 17:59:04 -05:00
|
|
|
if(db->pkgcache == NULL){
|
|
|
|
closedir(dbdir);
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
|
2011-02-07 17:59:04 -05:00
|
|
|
}
|
2011-01-24 20:49:34 -05:00
|
|
|
|
2009-01-19 14:45:12 -05:00
|
|
|
while((ent = readdir(dbdir)) != NULL) {
|
2008-05-12 19:56:14 -04:00
|
|
|
const char *name = ent->d_name;
|
2010-10-09 09:31:29 -04:00
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_pkg_t *pkg;
|
2008-01-11 01:01:58 -05:00
|
|
|
|
2008-05-12 19:56:14 -04:00
|
|
|
if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
2010-10-05 12:44:32 -04:00
|
|
|
if(!is_dir(dbpath, ent)) {
|
2008-05-12 19:56:14 -04:00
|
|
|
continue;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2007-01-31 01:48:06 -05:00
|
|
|
|
2008-05-13 20:03:54 -04:00
|
|
|
pkg = _alpm_pkg_new();
|
2007-01-31 01:48:06 -05:00
|
|
|
if(pkg == NULL) {
|
2009-01-19 14:45:12 -05:00
|
|
|
closedir(dbdir);
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2007-06-17 23:25:07 -04:00
|
|
|
/* split the db entry name */
|
2010-10-27 02:41:01 -04:00
|
|
|
if(_alpm_splitname(name, &(pkg->name), &(pkg->version),
|
|
|
|
&(pkg->name_hash)) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
|
2008-05-12 19:56:14 -04:00
|
|
|
name);
|
|
|
|
_alpm_pkg_free(pkg);
|
2007-05-18 02:19:00 -04:00
|
|
|
continue;
|
2007-01-31 01:48:06 -05:00
|
|
|
}
|
2007-03-03 03:13:59 -05:00
|
|
|
|
2009-11-13 10:42:42 -05:00
|
|
|
/* duplicated database entries are not allowed */
|
2011-01-24 20:49:34 -05:00
|
|
|
if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
|
2009-11-13 10:42:42 -05:00
|
|
|
_alpm_pkg_free(pkg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
pkg->origin = PKG_FROM_LOCALDB;
|
|
|
|
pkg->origin_data.db = db;
|
|
|
|
pkg->ops = &local_pkg_ops;
|
2011-06-03 13:44:01 -04:00
|
|
|
pkg->handle = db->handle;
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
|
2007-03-03 03:13:59 -05:00
|
|
|
/* explicitly read with only 'BASE' data, accessors will handle the rest */
|
2011-06-28 23:02:58 -04:00
|
|
|
if(local_db_read(pkg, INFRQ_BASE) == -1) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
|
2007-04-26 21:08:34 -04:00
|
|
|
_alpm_pkg_free(pkg);
|
2008-05-12 19:56:14 -04:00
|
|
|
continue;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2010-10-13 04:04:07 -04:00
|
|
|
|
2008-05-12 19:56:14 -04:00
|
|
|
/* add to the collection */
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
|
2008-05-12 19:56:14 -04:00
|
|
|
pkg->name, db->treename);
|
2011-01-24 20:49:34 -05:00
|
|
|
db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
|
2008-05-12 19:56:14 -04:00
|
|
|
count++;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2009-01-19 14:45:12 -05:00
|
|
|
closedir(dbdir);
|
2011-01-24 20:49:34 -05:00
|
|
|
if(count > 0) {
|
|
|
|
db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
|
|
|
|
}
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
|
2011-05-02 18:25:45 -04:00
|
|
|
count, db->treename);
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return count;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2010-10-10 23:47:18 -04:00
|
|
|
/* Note: the return value must be freed by the caller */
|
2011-11-22 20:09:58 -05:00
|
|
|
char *_alpm_local_db_pkgpath(alpm_db_t *db, alpm_pkg_t *info,
|
|
|
|
const char *filename)
|
2010-10-10 23:47:18 -04:00
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
char *pkgpath;
|
|
|
|
const char *dbpath;
|
|
|
|
|
|
|
|
dbpath = _alpm_db_path(db);
|
|
|
|
len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
|
2011-09-19 14:43:13 -04:00
|
|
|
len += filename ? strlen(filename) : 0;
|
2011-07-01 12:01:39 -04:00
|
|
|
MALLOC(pkgpath, len, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
|
2011-09-19 14:43:13 -04:00
|
|
|
sprintf(pkgpath, "%s%s-%s/%s", dbpath, info->name, info->version,
|
|
|
|
filename ? filename : "");
|
2011-03-20 20:45:57 -04:00
|
|
|
return pkgpath;
|
2010-10-10 23:47:18 -04:00
|
|
|
}
|
|
|
|
|
2011-07-03 14:37:04 -04:00
|
|
|
#define READ_NEXT() do { \
|
|
|
|
if(fgets(line, sizeof(line), fp) == NULL && !feof(fp)) goto error; \
|
2011-07-29 19:49:38 -04:00
|
|
|
_alpm_strip_newline(line); \
|
2011-07-03 14:37:04 -04:00
|
|
|
} while(0)
|
|
|
|
|
|
|
|
#define READ_AND_STORE(f) do { \
|
|
|
|
READ_NEXT(); \
|
|
|
|
STRDUP(f, line, goto error); \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
#define READ_AND_STORE_ALL(f) do { \
|
|
|
|
char *linedup; \
|
2011-09-18 18:32:15 -04:00
|
|
|
if(fgets(line, sizeof(line), fp) == NULL) {\
|
|
|
|
if(!feof(fp)) goto error; else break; \
|
|
|
|
} \
|
2011-07-29 19:49:38 -04:00
|
|
|
if(_alpm_strip_newline(line) == 0) break; \
|
2011-07-03 14:37:04 -04:00
|
|
|
STRDUP(linedup, line, goto error); \
|
|
|
|
f = alpm_list_add(f, linedup); \
|
|
|
|
} while(1) /* note the while(1) and not (0) */
|
2010-10-10 23:47:18 -04:00
|
|
|
|
2011-08-09 02:00:16 -04:00
|
|
|
#define READ_AND_SPLITDEP(f) do { \
|
2011-09-18 18:32:15 -04:00
|
|
|
if(fgets(line, sizeof(line), fp) == NULL) {\
|
|
|
|
if(!feof(fp)) goto error; else break; \
|
|
|
|
} \
|
2011-08-09 02:00:16 -04:00
|
|
|
if(_alpm_strip_newline(line) == 0) break; \
|
|
|
|
f = alpm_list_add(f, _alpm_splitdep(line)); \
|
|
|
|
} while(1) /* note the while(1) and not (0) */
|
|
|
|
|
2011-06-28 23:02:58 -04:00
|
|
|
static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
|
2006-03-02 14:06:52 -05:00
|
|
|
{
|
|
|
|
FILE *fp = NULL;
|
2010-07-07 18:12:42 -04:00
|
|
|
char line[1024];
|
2011-09-19 14:43:13 -04:00
|
|
|
char *pkgpath;
|
2011-06-28 23:02:58 -04:00
|
|
|
alpm_db_t *db = info->origin_data.db;
|
2006-11-01 01:30:47 -05:00
|
|
|
|
2007-03-11 23:02:57 -04:00
|
|
|
/* bitmask logic here:
|
|
|
|
* infolevel: 00001111
|
|
|
|
* inforeq: 00010100
|
|
|
|
* & result: 00000100
|
|
|
|
* == to inforeq? nope, we need to load more info. */
|
|
|
|
if((info->infolevel & inforeq) == inforeq) {
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
/* already loaded all of this info, do nothing */
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2006-11-22 04:03:41 -05:00
|
|
|
}
|
2011-07-29 18:03:07 -04:00
|
|
|
|
|
|
|
if(info->infolevel & INFRQ_ERROR) {
|
|
|
|
/* We've encountered an error loading this package before. Don't attempt
|
|
|
|
* repeated reloads, just give up. */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
|
2008-01-01 20:57:02 -05:00
|
|
|
info->name, inforeq);
|
2006-11-01 01:30:47 -05:00
|
|
|
|
2011-09-28 05:43:23 -04:00
|
|
|
pkgpath = _alpm_local_db_pkgpath(db, info, NULL);
|
2011-09-19 14:43:13 -04:00
|
|
|
if(!pkgpath || access(pkgpath, F_OK)) {
|
2006-03-02 14:06:52 -05:00
|
|
|
/* directory doesn't exist or can't be opened */
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
|
2007-07-10 14:24:58 -04:00
|
|
|
info->name, info->version, db->treename);
|
2008-05-30 02:52:27 -04:00
|
|
|
goto error;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(pkgpath);
|
|
|
|
|
|
|
|
/* clear out 'line', to be certain - and to make valgrind happy */
|
|
|
|
memset(line, 0, sizeof(line));
|
2006-03-02 14:06:52 -05:00
|
|
|
|
|
|
|
/* DESC */
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
if(inforeq & INFRQ_DESC && !(info->infolevel & INFRQ_DESC)) {
|
2011-09-28 05:43:23 -04:00
|
|
|
char *path = _alpm_local_db_pkgpath(db, info, "desc");
|
2011-09-19 14:43:13 -04:00
|
|
|
if(!path || (fp = fopen(path, "r")) == NULL) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2006-03-02 14:06:52 -05:00
|
|
|
goto error;
|
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2006-03-02 14:06:52 -05:00
|
|
|
while(!feof(fp)) {
|
2011-08-28 23:20:41 -04:00
|
|
|
if(fgets(line, sizeof(line), fp) == NULL && !feof(fp)) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if(_alpm_strip_newline(line) == 0) {
|
|
|
|
/* length of stripped line was zero */
|
|
|
|
continue;
|
|
|
|
}
|
2008-05-03 13:59:11 -04:00
|
|
|
if(strcmp(line, "%NAME%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
|
|
|
if(strcmp(line, info->name) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
|
2008-05-03 13:59:11 -04:00
|
|
|
"mismatch on package %s\n"), db->treename, info->name);
|
|
|
|
}
|
|
|
|
} else if(strcmp(line, "%VERSION%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
|
|
|
if(strcmp(line, info->version) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
|
2008-05-03 13:59:11 -04:00
|
|
|
"mismatch on package %s\n"), db->treename, info->name);
|
|
|
|
}
|
|
|
|
} else if(strcmp(line, "%DESC%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE(info->desc);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%GROUPS%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE_ALL(info->groups);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%URL%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE(info->url);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%LICENSE%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE_ALL(info->licenses);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%ARCH%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE(info->arch);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%BUILDDATE%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
2011-01-07 21:35:43 -05:00
|
|
|
info->builddate = _alpm_parsedate(line);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%INSTALLDATE%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
2011-01-07 21:35:43 -05:00
|
|
|
info->installdate = _alpm_parsedate(line);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%PACKAGER%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE(info->packager);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%REASON%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
2011-08-29 13:12:54 -04:00
|
|
|
info->reason = (alpm_pkgreason_t)atoi(line);
|
2010-10-11 01:06:10 -04:00
|
|
|
} else if(strcmp(line, "%SIZE%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_NEXT();
|
2011-09-02 20:26:07 -04:00
|
|
|
info->isize = _alpm_strtoofft(line);
|
2008-01-11 01:01:58 -05:00
|
|
|
} else if(strcmp(line, "%REPLACES%") == 0) {
|
2011-08-09 02:00:16 -04:00
|
|
|
READ_AND_SPLITDEP(info->replaces);
|
2010-10-30 01:35:43 -04:00
|
|
|
} else if(strcmp(line, "%DEPENDS%") == 0) {
|
2011-08-09 02:00:16 -04:00
|
|
|
READ_AND_SPLITDEP(info->depends);
|
2010-10-30 01:35:43 -04:00
|
|
|
} else if(strcmp(line, "%OPTDEPENDS%") == 0) {
|
2011-07-03 14:37:04 -04:00
|
|
|
READ_AND_STORE_ALL(info->optdepends);
|
2010-10-30 01:35:43 -04:00
|
|
|
} else if(strcmp(line, "%CONFLICTS%") == 0) {
|
2011-08-09 02:00:16 -04:00
|
|
|
READ_AND_SPLITDEP(info->conflicts);
|
2010-10-30 01:35:43 -04:00
|
|
|
} else if(strcmp(line, "%PROVIDES%") == 0) {
|
2011-08-09 02:00:16 -04:00
|
|
|
READ_AND_SPLITDEP(info->provides);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
fp = NULL;
|
2011-07-29 18:03:07 -04:00
|
|
|
info->infolevel |= INFRQ_DESC;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2010-10-30 01:35:43 -04:00
|
|
|
/* FILES */
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
if(inforeq & INFRQ_FILES && !(info->infolevel & INFRQ_FILES)) {
|
2011-09-28 05:43:23 -04:00
|
|
|
char *path = _alpm_local_db_pkgpath(db, info, "files");
|
2011-09-19 14:43:13 -04:00
|
|
|
if(!path || (fp = fopen(path, "r")) == NULL) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2006-03-02 14:06:52 -05:00
|
|
|
goto error;
|
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2010-10-30 01:35:43 -04:00
|
|
|
while(fgets(line, sizeof(line), fp)) {
|
2011-07-29 19:49:38 -04:00
|
|
|
_alpm_strip_newline(line);
|
2010-10-30 01:35:43 -04:00
|
|
|
if(strcmp(line, "%FILES%") == 0) {
|
2011-11-22 20:09:58 -05:00
|
|
|
size_t files_count = 0, files_size = 0, len;
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
alpm_file_t *files = NULL;
|
|
|
|
|
2011-11-22 20:09:58 -05:00
|
|
|
while(fgets(line, sizeof(line), fp) &&
|
|
|
|
(len = _alpm_strip_newline(line))) {
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
if(files_count >= files_size) {
|
|
|
|
size_t old_size = files_size;
|
|
|
|
if(files_size == 0) {
|
|
|
|
files_size = 8;
|
|
|
|
} else {
|
|
|
|
files_size *= 2;
|
|
|
|
}
|
|
|
|
files = realloc(files, sizeof(alpm_file_t) * files_size);
|
|
|
|
if(!files) {
|
|
|
|
ALLOC_FAIL(sizeof(alpm_file_t) * files_size);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/* ensure all new memory is zeroed out, in both the initial
|
|
|
|
* allocation and later reallocs */
|
|
|
|
memset(files + old_size, 0,
|
|
|
|
sizeof(alpm_file_t) * (files_size - old_size));
|
|
|
|
}
|
2011-11-22 20:09:58 -05:00
|
|
|
/* since we know the length of the file string already,
|
|
|
|
* we can do malloc + memcpy rather than strdup */
|
|
|
|
files[files_count].name = malloc(len + 1);
|
|
|
|
if(files[files_count].name == NULL) {
|
|
|
|
ALLOC_FAIL(len);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
memcpy(files[files_count].name, line, len + 1);
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
files_count++;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
/* attempt to hand back any memory we don't need */
|
|
|
|
files = realloc(files, sizeof(alpm_file_t) * files_count);
|
|
|
|
info->files.count = files_count;
|
|
|
|
info->files.files = files;
|
2010-10-30 01:35:43 -04:00
|
|
|
} else if(strcmp(line, "%BACKUP%") == 0) {
|
2011-07-29 19:49:38 -04:00
|
|
|
while(fgets(line, sizeof(line), fp) && _alpm_strip_newline(line)) {
|
2011-06-28 00:39:43 -04:00
|
|
|
alpm_backup_t *backup;
|
|
|
|
CALLOC(backup, 1, sizeof(alpm_backup_t), goto error);
|
2011-06-16 14:15:11 -04:00
|
|
|
if(_alpm_split_backup(line, &backup)) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
info->backup = alpm_list_add(info->backup, backup);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2007-02-28 11:37:24 -05:00
|
|
|
}
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
fp = NULL;
|
2011-07-29 18:03:07 -04:00
|
|
|
info->infolevel |= INFRQ_FILES;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* INSTALL */
|
Fix double filelist issue when upgrading a package
Due to the way we funk around with package data loading, we had a condition
where the filelist got doubled up because it was loaded twice.
Packages are originally loaded with INFRQ_BASE. In an upgrade/sync, the
package is checked for file conflicts next, leaving us in an "INFRQ_BASE |
INFRQ_FILES" state. Later, when committing a single package, we have an
explicit call to _alpm_local_db_read() with INFRQ_ALL as the level. Because
the package's level did not match this, we skipped over our previous "does
the incoming level match where I'm at" shortcut, and continued to load
things again, because of a lack of fine-grained checking for each of DESC,
FILES, and INSTALL.
The end result is we loaded the filelist twice, causing our remove logic to
iterate twice over the installed files, spewing a bunch of "cannot find file
X" messages.
Fix the problem by doing a bit more bitmasking logic throughout the load
method, and also fix the sanity check at the beginning of the function- this
should *only* be used for local packages as opposed to the "not a package"
check that was there before.
A debug log message was added to upgraderemove as well to match the one
already in the normal remove codepath.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-01-11 19:46:10 -05:00
|
|
|
if(inforeq & INFRQ_SCRIPTLET && !(info->infolevel & INFRQ_SCRIPTLET)) {
|
2011-09-28 05:43:23 -04:00
|
|
|
char *path = _alpm_local_db_pkgpath(db, info, "install");
|
2008-06-15 20:15:36 -04:00
|
|
|
if(access(path, F_OK) == 0) {
|
2006-03-02 14:06:52 -05:00
|
|
|
info->scriptlet = 1;
|
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2011-07-29 18:03:07 -04:00
|
|
|
info->infolevel |= INFRQ_SCRIPTLET;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2006-03-02 14:06:52 -05:00
|
|
|
|
|
|
|
error:
|
2011-07-29 18:03:07 -04:00
|
|
|
info->infolevel |= INFRQ_ERROR;
|
2006-03-02 14:06:52 -05:00
|
|
|
if(fp) {
|
|
|
|
fclose(fp);
|
|
|
|
}
|
2011-03-20 20:45:57 -04:00
|
|
|
return -1;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
int _alpm_local_db_prepare(alpm_db_t *db, alpm_pkg_t *info)
|
2009-01-02 04:12:22 -05:00
|
|
|
{
|
|
|
|
mode_t oldmask;
|
|
|
|
int retval = 0;
|
2011-09-19 14:43:13 -04:00
|
|
|
char *pkgpath;
|
2009-01-02 04:12:22 -05:00
|
|
|
|
2009-01-19 16:54:00 -05:00
|
|
|
if(checkdbdir(db) != 0) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return -1;
|
2009-01-19 16:54:00 -05:00
|
|
|
}
|
2009-01-02 04:12:22 -05:00
|
|
|
|
2009-01-19 16:54:00 -05:00
|
|
|
oldmask = umask(0000);
|
2011-09-28 05:43:23 -04:00
|
|
|
pkgpath = _alpm_local_db_pkgpath(db, info, NULL);
|
2009-01-02 04:12:22 -05:00
|
|
|
|
|
|
|
if((retval = mkdir(pkgpath, 0755)) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not create directory %s: %s\n"),
|
2009-01-19 16:54:00 -05:00
|
|
|
pkgpath, strerror(errno));
|
2009-01-02 04:12:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
free(pkgpath);
|
|
|
|
umask(oldmask);
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return retval;
|
2009-01-02 04:12:22 -05:00
|
|
|
}
|
|
|
|
|
2011-06-28 00:59:04 -04:00
|
|
|
int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
|
2006-03-02 14:06:52 -05:00
|
|
|
{
|
|
|
|
FILE *fp = NULL;
|
|
|
|
mode_t oldmask;
|
2011-09-19 14:43:13 -04:00
|
|
|
alpm_list_t *lp;
|
2006-03-02 14:06:52 -05:00
|
|
|
int retval = 0;
|
|
|
|
|
2011-08-28 20:46:09 -04:00
|
|
|
if(db == NULL || info == NULL || !(db->status & DB_STATUS_LOCAL)) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return -1;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure we have a sane umask */
|
2009-01-02 04:12:22 -05:00
|
|
|
oldmask = umask(0022);
|
2006-03-02 14:06:52 -05:00
|
|
|
|
|
|
|
/* DESC */
|
|
|
|
if(inforeq & INFRQ_DESC) {
|
2011-09-19 14:43:13 -04:00
|
|
|
char *path;
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
|
2007-07-10 14:24:58 -04:00
|
|
|
info->name, info->version);
|
2011-09-28 05:43:23 -04:00
|
|
|
path = _alpm_local_db_pkgpath(db, info, "desc");
|
2011-09-19 14:43:13 -04:00
|
|
|
if(!path || (fp = fopen(path, "w")) == NULL) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
|
2011-06-07 17:13:58 -04:00
|
|
|
path, strerror(errno));
|
2007-01-24 03:51:50 -05:00
|
|
|
retval = -1;
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2006-03-02 14:06:52 -05:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2006-03-02 14:06:52 -05:00
|
|
|
fprintf(fp, "%%NAME%%\n%s\n\n"
|
2007-02-12 20:46:33 -05:00
|
|
|
"%%VERSION%%\n%s\n\n", info->name, info->version);
|
2008-01-11 01:01:58 -05:00
|
|
|
if(info->desc) {
|
2007-02-12 20:46:33 -05:00
|
|
|
fprintf(fp, "%%DESC%%\n"
|
|
|
|
"%s\n\n", info->desc);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
if(info->groups) {
|
|
|
|
fputs("%GROUPS%\n", fp);
|
|
|
|
for(lp = info->groups; lp; lp = lp->next) {
|
|
|
|
fprintf(fp, "%s\n", (char *)lp->data);
|
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2008-05-22 17:59:10 -04:00
|
|
|
if(info->replaces) {
|
|
|
|
fputs("%REPLACES%\n", fp);
|
|
|
|
for(lp = info->replaces; lp; lp = lp->next) {
|
2011-08-09 02:00:16 -04:00
|
|
|
char *depstring = alpm_dep_compute_string(lp->data);
|
|
|
|
fprintf(fp, "%s\n", depstring);
|
|
|
|
free(depstring);
|
2008-05-22 17:59:10 -04:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2010-10-13 07:18:03 -04:00
|
|
|
if(info->url) {
|
|
|
|
fprintf(fp, "%%URL%%\n"
|
|
|
|
"%s\n\n", info->url);
|
|
|
|
}
|
|
|
|
if(info->licenses) {
|
|
|
|
fputs("%LICENSE%\n", fp);
|
|
|
|
for(lp = info->licenses; lp; lp = lp->next) {
|
|
|
|
fprintf(fp, "%s\n", (char *)lp->data);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2010-10-13 07:18:03 -04:00
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
|
|
|
if(info->arch) {
|
|
|
|
fprintf(fp, "%%ARCH%%\n"
|
|
|
|
"%s\n\n", info->arch);
|
|
|
|
}
|
|
|
|
if(info->builddate) {
|
|
|
|
fprintf(fp, "%%BUILDDATE%%\n"
|
2011-09-07 11:21:47 -04:00
|
|
|
"%jd\n\n", (intmax_t)info->builddate);
|
2010-10-13 07:18:03 -04:00
|
|
|
}
|
|
|
|
if(info->installdate) {
|
|
|
|
fprintf(fp, "%%INSTALLDATE%%\n"
|
2011-09-07 11:21:47 -04:00
|
|
|
"%jd\n\n", (intmax_t)info->installdate);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
2010-10-13 07:18:03 -04:00
|
|
|
if(info->packager) {
|
|
|
|
fprintf(fp, "%%PACKAGER%%\n"
|
|
|
|
"%s\n\n", info->packager);
|
|
|
|
}
|
|
|
|
if(info->isize) {
|
|
|
|
/* only write installed size, csize is irrelevant once installed */
|
|
|
|
fprintf(fp, "%%SIZE%%\n"
|
|
|
|
"%jd\n\n", (intmax_t)info->isize);
|
|
|
|
}
|
|
|
|
if(info->reason) {
|
|
|
|
fprintf(fp, "%%REASON%%\n"
|
|
|
|
"%u\n\n", info->reason);
|
|
|
|
}
|
2006-03-02 14:06:52 -05:00
|
|
|
if(info->depends) {
|
|
|
|
fputs("%DEPENDS%\n", fp);
|
|
|
|
for(lp = info->depends; lp; lp = lp->next) {
|
2008-08-26 06:57:08 -04:00
|
|
|
char *depstring = alpm_dep_compute_string(lp->data);
|
2007-11-13 00:01:14 -05:00
|
|
|
fprintf(fp, "%s\n", depstring);
|
|
|
|
free(depstring);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2007-09-26 00:02:30 -04:00
|
|
|
if(info->optdepends) {
|
|
|
|
fputs("%OPTDEPENDS%\n", fp);
|
|
|
|
for(lp = info->optdepends; lp; lp = lp->next) {
|
|
|
|
fprintf(fp, "%s\n", (char *)lp->data);
|
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2006-03-02 14:06:52 -05:00
|
|
|
if(info->conflicts) {
|
|
|
|
fputs("%CONFLICTS%\n", fp);
|
|
|
|
for(lp = info->conflicts; lp; lp = lp->next) {
|
2011-08-09 02:00:16 -04:00
|
|
|
char *depstring = alpm_dep_compute_string(lp->data);
|
|
|
|
fprintf(fp, "%s\n", depstring);
|
|
|
|
free(depstring);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
|
|
|
if(info->provides) {
|
|
|
|
fputs("%PROVIDES%\n", fp);
|
|
|
|
for(lp = info->provides; lp; lp = lp->next) {
|
2011-08-09 02:00:16 -04:00
|
|
|
char *depstring = alpm_dep_compute_string(lp->data);
|
|
|
|
fprintf(fp, "%s\n", depstring);
|
|
|
|
free(depstring);
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2010-10-30 01:35:43 -04:00
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
fp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FILES */
|
|
|
|
if(inforeq & INFRQ_FILES) {
|
2011-09-19 14:43:13 -04:00
|
|
|
char *path;
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
|
2010-10-30 01:35:43 -04:00
|
|
|
info->name, info->version);
|
2011-09-28 05:43:23 -04:00
|
|
|
path = _alpm_local_db_pkgpath(db, info, "files");
|
2011-09-19 14:43:13 -04:00
|
|
|
if(!path || (fp = fopen(path, "w")) == NULL) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
|
2011-06-07 17:13:58 -04:00
|
|
|
path, strerror(errno));
|
2010-10-30 01:35:43 -04:00
|
|
|
retval = -1;
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
2010-10-30 01:35:43 -04:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2011-09-19 14:43:13 -04:00
|
|
|
free(path);
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
if(info->files.count) {
|
|
|
|
size_t i;
|
2010-10-30 01:35:43 -04:00
|
|
|
fprintf(fp, "%%FILES%%\n");
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
for(i = 0; i < info->files.count; i++) {
|
|
|
|
const alpm_file_t *file = info->files.files + i;
|
2011-06-16 14:16:49 -04:00
|
|
|
fprintf(fp, "%s\n", file->name);
|
2010-10-30 01:35:43 -04:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
|
|
|
if(info->backup) {
|
|
|
|
fprintf(fp, "%%BACKUP%%\n");
|
|
|
|
for(lp = info->backup; lp; lp = lp->next) {
|
2011-06-16 14:16:49 -04:00
|
|
|
const alpm_backup_t *backup = lp->data;
|
2011-06-16 14:15:11 -04:00
|
|
|
fprintf(fp, "%s\t%s\n", backup->name, backup->hash);
|
2010-10-30 01:35:43 -04:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
2006-03-02 14:06:52 -05:00
|
|
|
fclose(fp);
|
|
|
|
fp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* INSTALL */
|
2006-10-15 15:31:03 -04:00
|
|
|
/* nothing needed here (script is automatically extracted) */
|
2006-03-02 14:06:52 -05:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
umask(oldmask);
|
|
|
|
|
|
|
|
if(fp) {
|
|
|
|
fclose(fp);
|
|
|
|
}
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return retval;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
int _alpm_local_db_remove(alpm_db_t *db, alpm_pkg_t *info)
|
2006-03-02 14:06:52 -05:00
|
|
|
{
|
2008-05-30 02:52:27 -04:00
|
|
|
int ret = 0;
|
2011-09-28 05:43:23 -04:00
|
|
|
char *pkgpath = _alpm_local_db_pkgpath(db, info, NULL);
|
2006-03-02 14:06:52 -05:00
|
|
|
|
2011-09-28 05:43:23 -04:00
|
|
|
/* TODO explicit file removes and then an rmdir? */
|
2008-05-30 02:52:27 -04:00
|
|
|
ret = _alpm_rmrf(pkgpath);
|
|
|
|
free(pkgpath);
|
|
|
|
if(ret != 0) {
|
|
|
|
ret = -1;
|
|
|
|
}
|
2011-03-20 20:45:57 -04:00
|
|
|
return ret;
|
2006-03-02 14:06:52 -05:00
|
|
|
}
|
|
|
|
|
2010-10-09 06:16:15 -04:00
|
|
|
struct db_operations local_db_ops = {
|
2011-06-08 00:05:21 -04:00
|
|
|
.validate = local_db_validate,
|
2010-12-13 21:19:32 -05:00
|
|
|
.populate = local_db_populate,
|
2010-10-09 06:16:15 -04:00
|
|
|
.unregister = _alpm_db_unregister,
|
|
|
|
};
|
|
|
|
|
2011-06-28 00:11:43 -04:00
|
|
|
alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle)
|
2010-10-09 06:16:15 -04:00
|
|
|
{
|
2011-06-28 00:11:43 -04:00
|
|
|
alpm_db_t *db;
|
2010-10-09 06:16:15 -04:00
|
|
|
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "registering local database\n");
|
2010-10-09 06:16:15 -04:00
|
|
|
|
|
|
|
db = _alpm_db_new("local", 1);
|
|
|
|
if(db == NULL) {
|
2011-07-01 12:01:39 -04:00
|
|
|
handle->pm_errno = ALPM_ERR_DB_CREATE;
|
2011-06-03 16:24:01 -04:00
|
|
|
return NULL;
|
2010-10-09 06:16:15 -04:00
|
|
|
}
|
2011-03-20 20:56:55 -04:00
|
|
|
db->ops = &local_db_ops;
|
2011-06-03 13:06:25 -04:00
|
|
|
db->handle = handle;
|
2010-10-09 06:16:15 -04:00
|
|
|
|
2011-04-20 20:54:01 -04:00
|
|
|
if(local_db_validate(db)) {
|
|
|
|
/* pm_errno set in local_db_validate() */
|
|
|
|
_alpm_db_free(db);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-09 06:16:15 -04:00
|
|
|
handle->db_local = db;
|
2011-03-20 20:45:57 -04:00
|
|
|
return db;
|
2010-10-09 06:16:15 -04:00
|
|
|
}
|
|
|
|
|
2006-03-02 14:06:52 -05:00
|
|
|
/* vim: set ts=2 sw=2 noet: */
|