Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
librazor/merger.c
author J. Ali Harlow <ali@juiblex.co.uk>
Wed Aug 20 18:57:59 2014 +0100 (2014-08-20)
changeset 439 f28bb31024b4
parent 403 e63951c1d0f8
child 458 3f841a46eab5
permissions -rw-r--r--
Add secondary text to errors 
     1 /*

     2  * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

     3  * Copyright (C) 2008  Red Hat, Inc

     4  * Copyright (C) 2009-2011  J. Ali Harlow <ali@juiblex.co.uk>

     5  *

     6  * This program is free software; you can redistribute it and/or modify

     7  * it under the terms of the GNU General Public License as published by

     8  * the Free Software Foundation; either version 2 of the License, or

     9  * (at your option) any later version.

    10  *

    11  * This program is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14  * GNU General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU General Public License along

    17  * with this program; if not, write to the Free Software Foundation, Inc.,

    18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

    19  */

    20 

    21 #include "config.h"

    22 #include <string.h>

    23 #include <assert.h>

    24 #include "razor-internal.h"

    25 #include "razor.h"

    26 

    27 #define UPSTREAM_SOURCE 0x80

    28 

    29 struct source {

    30 	struct razor_set *set;

    31 	uint32_t *property_map;

    32 	uint32_t *file_map;

    33 };

    34 

    35 struct razor_merger {

    36 	int committed;

    37 	struct razor_set *set;

    38 	struct hashtable table;

    39 	struct hashtable file_table;

    40 	struct hashtable details_table;

    41 	struct source source1;

    42 	struct source source2;

    43 };

    44 

    45 struct razor_merger *

    46 razor_merger_create(struct razor_set *set1, struct razor_set *set2)

    47 {

    48 	struct razor_merger *merger;

    49 	int count;

    50 	size_t size;

    51 	uint32_t header_version;

    52 

    53 	merger = zalloc(sizeof *merger);

    54 	merger->set = razor_set_create();

    55 	if (set1->packages.size) {

    56 		header_version = razor_set_get_header_version(set1);

    57 		if (set2->packages.size &&

    58 		    razor_set_get_header_version(set2) > header_version)

    59 			header_version = razor_set_get_header_version(set2);

    60 	} else

    61 		header_version = razor_set_get_header_version(set2);

    62 	razor_set_set_header_version(merger->set, header_version);

    63 	hashtable_init(&merger->table, &merger->set->string_pool);

    64 	hashtable_init(&merger->file_table, &merger->set->file_string_pool);

    65 	hashtable_init(&merger->details_table,

    66 		       &merger->set->details_string_pool);

    67 

    68 	merger->source1.set = set1;

    69 	count = set1->properties.size / sizeof (struct razor_property);

    70 	size = count * sizeof merger->source1.property_map[0];

    71 	merger->source1.property_map = zalloc(size);

    72 	count = set1->files.size / sizeof (struct razor_entry);

    73 	size = count * sizeof merger->source1.file_map[0];

    74 	merger->source1.file_map = zalloc(size);

    75 

    76 	merger->source2.set = set2;

    77 	count = set2->properties.size / sizeof (struct razor_property);

    78 	size = count * sizeof merger->source2.property_map[0];

    79 	merger->source2.property_map = zalloc(size);

    80 	count = set2->files.size / sizeof (struct razor_entry);

    81 	size = count * sizeof merger->source2.file_map[0];

    82 	merger->source2.file_map = zalloc(size);

    83 

    84 	return merger;

    85 }

    86 

    87 void

    88 razor_merger_add_package(struct razor_merger *merger,

    89 			 struct razor_package *package)

    90 {

    91 	char *pool, *details_pool, *s;

    92 	struct list *r;

    93 	struct razor_package *p;

    94 	struct razor_set *set1;

    95 	struct source *source;

    96 	uint32_t flags, *prefix;

    97 	struct array install_prefixes;

    98 

    99 	assert(merger->committed == 0);

   100 

   101 	set1 = merger->source1.set;

   102 	if (set1->packages.data <= (void *) package &&

   103 	    (void *) package < set1->packages.data + set1->packages.size) {

   104 		source = &merger->source1;

   105 		flags = 0;

   106 	} else {

   107 		source = &merger->source2;

   108 		flags = UPSTREAM_SOURCE;

   109 	}

   110 

   111 	pool = source->set->string_pool.data;

   112 	details_pool = source->set->details_string_pool.data;

   113 	p = array_add(&merger->set->packages, sizeof *p);

   114 	p->name = hashtable_tokenize(&merger->table, &pool[package->name]);

   115 	p->flags = flags;

   116 	p->version = hashtable_tokenize(&merger->table,

   117 					&pool[package->version]);

   118 	p->arch = hashtable_tokenize(&merger->table,

   119 				     &pool[package->arch]);

   120 	if (source->set->details_string_pool.size) {

   121 		p->summary = hashtable_tokenize(&merger->details_table,

   122 						&details_pool[package->summary]);

   123 		p->description = hashtable_tokenize(&merger->details_table,

   124 						    &details_pool[package->description]);

   125 		p->url = hashtable_tokenize(&merger->details_table,

   126 					    &details_pool[package->url]);

   127 		p->license = hashtable_tokenize(&merger->details_table,

   128 						&details_pool[package->license]);

   129 	} else {

   130 		p->summary = hashtable_tokenize(&merger->details_table, "");

   131 		p->description = hashtable_tokenize(&merger->details_table, "");

   132 		p->url = hashtable_tokenize(&merger->details_table, "");

   133 		p->license = hashtable_tokenize(&merger->details_table, "");

   134 	}

   135 

   136 	p->properties = package->properties;

   137 	r = list_first(&package->properties, &source->set->property_pool);

   138 	while (r) {

   139 		source->property_map[r->data] = 1;

   140 		r = list_next(r);

   141 	}

   142 

   143 	p->files = package->files;

   144 	r = list_first(&package->files, &source->set->file_pool);

   145 	while (r) {

   146 		source->file_map[r->data] = 1;

   147 		r = list_next(r);

   148 	}

   149 

   150 	array_init(&install_prefixes);

   151 	r = list_first(&package->install_prefixes, &source->set->prefix_pool);

   152 	while (r) {

   153 		s = (char *)source->set->string_pool.data + r->data;

   154 		prefix = array_add(&install_prefixes, sizeof *prefix);

   155 		*prefix = hashtable_tokenize(&merger->table, s);

   156 		r = list_next(r);

   157 	}

   158 	list_set_array(&p->install_prefixes, &merger->set->prefix_pool,

   159                        &install_prefixes, 0);

   160 	array_release(&install_prefixes);

   161 

   162 	p->preun.program = hashtable_tokenize(&merger->table,

   163 					      &pool[package->preun.program]);

   164 	p->preun.body = hashtable_tokenize(&merger->table,

   165 					   &pool[package->preun.body]);

   166 	p->postun.program = hashtable_tokenize(&merger->table,

   167 					       &pool[package->postun.program]);

   168 	p->postun.body = hashtable_tokenize(&merger->table,

   169 					    &pool[package->postun.body]);

   170 }

   171 

   172 static uint32_t

   173 add_property(struct razor_merger *merger,

   174 	     const char *name, uint32_t flags, const char *version)

   175 {

   176 	struct razor_property *p;

   177 

   178 	p = array_add(&merger->set->properties, sizeof *p);

   179 	p->name = hashtable_tokenize(&merger->table, name);

   180 	p->flags = flags;

   181 	p->version = hashtable_tokenize(&merger->table, version);

   182 

   183 	return p - (struct razor_property *) merger->set->properties.data;

   184 }

   185 

   186 static void

   187 merge_properties(struct razor_merger *merger)

   188 {

   189 	struct razor_property *p1, *p2;

   190 	struct razor_set *set1, *set2;

   191 	uint32_t *map1, *map2;

   192 	int i, j, cmp, count1, count2;

   193 	char *pool1, *pool2;

   194 

   195 	set1 = merger->source1.set;

   196 	set2 = merger->source2.set;

   197 	map1 = merger->source1.property_map;

   198 	map2 = merger->source2.property_map;

   199 

   200 	i = 0;

   201 	j = 0;

   202 	pool1 = set1->string_pool.data;

   203 	pool2 = set2->string_pool.data;

   204 

   205 	count1 = set1->properties.size / sizeof *p1;

   206 	count2 = set2->properties.size / sizeof *p2;

   207 	while (i < count1 || j < count2) {

   208 		if (i < count1 && map1[i] == 0) {

   209 			i++;

   210 			continue;

   211 		}

   212 		if (j < count2 && map2[j] == 0) {

   213 			j++;

   214 			continue;

   215 		}

   216 		p1 = (struct razor_property *) set1->properties.data + i;

   217 		p2 = (struct razor_property *) set2->properties.data + j;

   218 		if (i < count1 && j < count2)

   219 			cmp = strcmp(&pool1[p1->name], &pool2[p2->name]);

   220 		else if (i < count1)

   221 			cmp = -1;

   222 		else

   223 			cmp = 1;

   224 		if (cmp == 0)

   225 			cmp = p1->flags - p2->flags;

   226 		if (cmp == 0)

   227 			cmp = razor_versioncmp(&pool1[p1->version],

   228 					       &pool2[p2->version]);

   229 		if (cmp < 0) {

   230 			map1[i++] = add_property(merger,

   231 						 &pool1[p1->name],

   232 						 p1->flags,

   233 						 &pool1[p1->version]);

   234 		} else if (cmp > 0) {

   235 			map2[j++] = add_property(merger,

   236 						 &pool2[p2->name],

   237 						 p2->flags,

   238 						 &pool2[p2->version]);

   239 		} else  {

   240 			map1[i++] = map2[j++] =

   241 				add_property(merger,

   242 					     &pool1[p1->name],

   243 					     p1->flags,

   244 					     &pool1[p1->version]);

   245 		}

   246 	}

   247 }

   248 

   249 static void

   250 emit_properties(struct list_head *properties, struct array *source_pool,

   251 		uint32_t *map, struct array *pool)

   252 {

   253 	uint32_t r;

   254 	struct list *p, *q;

   255 

   256 	r = pool->size / sizeof *q;

   257 	p = list_first(properties, source_pool);

   258 	while (p) {

   259 		q = array_add(pool, sizeof *q);

   260 		q->data = map[p->data];

   261 		q->flags = p->flags;

   262 		p = list_next(p);

   263 	}

   264 

   265 	list_set_ptr(properties, r);

   266 }

   267 

   268 static uint32_t

   269 add_file(struct razor_merger *merger, const char *name)

   270 {

   271 	struct razor_entry *e;

   272 

   273 	e = array_add(&merger->set->files, sizeof *e);

   274 	e->name = hashtable_tokenize(&merger->file_table, name);

   275 	e->flags = 0;

   276 	e->start = 0;

   277 

   278 	return e - (struct razor_entry *)merger->set->files.data;

   279 }

   280 

   281 /* FIXME. Blah */

   282 static int

   283 fix_file_map(uint32_t *map,

   284 	     struct razor_entry *files,

   285 	     struct razor_entry *top)

   286 {

   287 	uint32_t e;

   288 	int found_file = 0;

   289 

   290 	e = top - files;

   291 	do {

   292 		if (files[e].start &&

   293 		    fix_file_map(map, files, &files[files[e].start]))

   294 			map[e] = 1;

   295 		if (map[e])

   296 			found_file = 1;

   297 	} while (!(files[e++].flags & RAZOR_ENTRY_LAST));

   298 

   299 	return found_file;

   300 }

   301 

   302 struct merge_directory {

   303 	uint32_t merged, dir1, dir2;

   304 };

   305 

   306 static void

   307 merge_one_directory(struct razor_merger *merger, struct merge_directory *md)

   308 {

   309 	struct razor_entry *root1, *root2, *mroot, *e1, *e2;

   310 	struct razor_set *set1, *set2;

   311 	struct array merge_stack;

   312 	struct merge_directory *child_md, *end_md;

   313 	uint32_t *map1, *map2, start, last;

   314 	int cmp;

   315 	char *pool1, *pool2;

   316 

   317 	set1 = merger->source1.set;

   318 	set2 = merger->source2.set;

   319 	map1 = merger->source1.file_map;

   320 	map2 = merger->source2.file_map;

   321 	pool1 = set1->file_string_pool.data;

   322 	pool2 = set2->file_string_pool.data;

   323 	root1 = (struct razor_entry *) set1->files.data;

   324 	root2 = (struct razor_entry *) set2->files.data;

   325 

   326 	array_init(&merge_stack);

   327 

   328 	start = merger->set->files.size / sizeof (struct razor_entry);

   329 	last = 0xFFFFFFFF;

   330 	e1 = md->dir1 != 0xFFFFFFFF ? root1 + md->dir1 : NULL;

   331 	e2 = md->dir2 != 0xFFFFFFFF ? root2 + md->dir2 : NULL;

   332 	while (e1 || e2) {

   333 		if (!e2 && !map1[e1 - root1]) {

   334 			if ((e1++)->flags & RAZOR_ENTRY_LAST)

   335 				e1 = NULL;

   336 			continue;

   337 		}

   338 		if (!e1 && !map2[e2 - root2]) {

   339 			if ((e2++)->flags & RAZOR_ENTRY_LAST)

   340 				e2 = NULL;

   341 			continue;

   342 		}

   343 		if (e1 && !map1[e1 - root1] &&

   344 		    e2 && !map2[e2 - root2]) {

   345 			if ((e1++)->flags & RAZOR_ENTRY_LAST)

   346 				e1 = NULL;

   347 			if ((e2++)->flags & RAZOR_ENTRY_LAST)

   348 				e2 = NULL;

   349 			continue;

   350 		}

   351 

   352 		if (!e1)

   353 			cmp = 1;

   354 		else if (!e2)

   355 			cmp = -1;

   356 		else {

   357 			cmp = strcmp (&pool1[e1->name],

   358 				      &pool2[e2->name]);

   359 		}

   360 

   361 		if (cmp < 0) {

   362 			if (map1[e1 - root1]) {

   363 				map1[e1 - root1] = last =

   364 					add_file(merger, &pool1[e1->name]);

   365 				if (e1->start) {

   366 					child_md = array_add(&merge_stack, sizeof (struct merge_directory));

   367 					child_md->merged = last;

   368 					child_md->dir1 = e1->start;

   369 					child_md->dir2 = 0xFFFFFFFF;

   370 				}

   371 			}

   372 			if ((e1++)->flags & RAZOR_ENTRY_LAST)

   373 				e1 = NULL;

   374 		} else if (cmp > 0) {

   375 			if (map2[e2 - root2]) {

   376 				map2[e2 - root2] = last =

   377 					add_file(merger, &pool2[e2->name]);

   378 				if (e2->start) {

   379 					child_md = array_add(&merge_stack, sizeof (struct merge_directory));

   380 					child_md->merged = last;

   381 					child_md->dir1 = 0xFFFFFFFF;

   382 					child_md->dir2 = e2->start;

   383 				}

   384 			}

   385 			if ((e2++)->flags & RAZOR_ENTRY_LAST)

   386 				e2 = NULL;

   387 		} else {

   388 			map1[e1 - root1] = map2[e2- root2] = last =

   389 				add_file(merger, &pool1[e1->name]);

   390 			if (e1->start || e2->start) {

   391 				child_md = array_add(&merge_stack, sizeof (struct merge_directory));

   392 				child_md->merged = last;

   393 				child_md->dir1 = e1->start ? e1->start : 0xFFFFFFFF;

   394 				child_md->dir2 = e2->start ? e2->start : 0xFFFFFFFF;

   395 			}

   396 			if ((e1++)->flags & RAZOR_ENTRY_LAST)

   397 				e1 = NULL;

   398 			if ((e2++)->flags & RAZOR_ENTRY_LAST)

   399 				e2 = NULL;

   400 		}

   401 	}

   402 

   403 	mroot = (struct razor_entry *)merger->set->files.data;

   404 	if (last != 0xFFFFFFFF) {

   405 		mroot[last].flags = RAZOR_ENTRY_LAST;

   406 		mroot[md->merged].start = start;

   407 	}

   408 

   409 	end_md = merge_stack.data + merge_stack.size;

   410 	for (child_md = merge_stack.data; child_md < end_md; child_md++)

   411 		merge_one_directory(merger, child_md);

   412 	array_release(&merge_stack);

   413 }

   414 

   415 static void

   416 merge_files(struct razor_merger *merger)

   417 {

   418 	struct razor_entry *root;

   419 	struct merge_directory md;

   420 	uint32_t *map1, *map2;

   421 

   422 	map1 = merger->source1.file_map;

   423 	map2 = merger->source2.file_map;

   424 

   425 	md.merged = 0;

   426 

   427 	if (merger->source1.set->files.size) {

   428 		root = (struct razor_entry *) merger->source1.set->files.data;

   429 		if (root->start)

   430 			fix_file_map(map1, root, root);

   431 		md.dir1 = 0;

   432 	} else {

   433 		md.dir1 = 0xFFFFFFFF;

   434 	}

   435 

   436 	if (merger->source2.set->files.size) {

   437 		root = (struct razor_entry *) merger->source2.set->files.data;

   438 		if (root->start)

   439 			fix_file_map(map2, root, root);

   440 		md.dir2 = 0;

   441 	} else {

   442 		md.dir2 = 0xFFFFFFFF;

   443 	}

   444 

   445 	/* Remove the unnamed root which razor_set_create() added */

   446 	array_release(&merger->set->files);

   447 	array_init(&merger->set->files);

   448 

   449 	merge_one_directory(merger, &md);

   450 }

   451 

   452 static void

   453 emit_files(struct list_head *files, struct array *source_pool,

   454 	   uint32_t *map, struct array *pool)

   455 {

   456 	uint32_t r;

   457 	struct list *p, *q;

   458 

   459 	r = pool->size / sizeof *q;

   460 	p = list_first(files, source_pool);

   461 	while (p) {

   462 		q = array_add(pool, sizeof *q);

   463 		q->data = map[p->data];

   464 		q->flags = p->flags;

   465 		p = list_next(p);

   466 	}

   467 

   468 	list_set_ptr(files, r);

   469 }

   470 

   471 /* Rebuild property->packages maps.  We can't just remap these, as a

   472  * property may have lost or gained a number of packages.  Allocate an

   473  * array per property and loop through the packages and add them to

   474  * the arrays for their properties. */

   475 static void

   476 rebuild_property_package_lists(struct razor_set *set)

   477 {

   478 	struct array *pkgs, *a;

   479 	struct razor_package *pkg, *pkg_end;

   480 	struct razor_property *prop, *prop_end;

   481 	struct list *r;

   482 	uint32_t *q;

   483 	int count;

   484 

   485 	count = set->properties.size / sizeof (struct razor_property);

   486 	pkgs = zalloc(count * sizeof *pkgs);

   487 	pkg_end = set->packages.data + set->packages.size;

   488 

   489 	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {

   490 		r = list_first(&pkg->properties, &set->property_pool);

   491 		while (r) {

   492 			q = array_add(&pkgs[r->data], sizeof *q);

   493 			*q = pkg - (struct razor_package *) set->packages.data;

   494 			r = list_next(r);

   495 		}

   496 	}

   497 

   498 	prop_end = set->properties.data + set->properties.size;

   499 	a = pkgs;

   500 	for (prop = set->properties.data; prop < prop_end; prop++, a++) {

   501 		list_set_array(&prop->packages, &set->package_pool, a, 0);

   502 		array_release(a);

   503 	}

   504 	free(pkgs);

   505 }

   506 

   507 static void

   508 rebuild_file_package_lists(struct razor_set *set)

   509 {

   510 	struct array *pkgs, *a;

   511 	struct razor_package *pkg, *pkg_end;

   512 	struct razor_entry *entry, *entry_end;

   513 	struct list *r;

   514 	uint32_t *q;

   515 	int count;

   516 

   517 	count = set->files.size / sizeof (struct razor_entry);

   518 	pkgs = zalloc(count * sizeof *pkgs);

   519 	pkg_end = set->packages.data + set->packages.size;

   520 

   521 	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {

   522 		r = list_first(&pkg->files, &set->file_pool);

   523 		while (r) {

   524 			q = array_add(&pkgs[r->data], sizeof *q);

   525 			*q = pkg - (struct razor_package *) set->packages.data;

   526 			r = list_next(r);

   527 		}

   528 	}

   529 

   530 	entry_end = set->files.data + set->files.size;

   531 	a = pkgs;

   532 	for (entry = set->files.data; entry < entry_end; entry++, a++) {

   533 		list_set_array(&entry->packages, &set->package_pool, a, 0);

   534 		array_release(a);

   535 	}

   536 	free(pkgs);

   537 }

   538 

   539 struct razor_set *

   540 razor_merger_commit(struct razor_merger *merger)

   541 {

   542 	struct razor_package *p, *pend;

   543 

   544 	/* As we built the package list, we filled out a bitvector of

   545 	 * the properties that are referenced by the packages in the

   546 	 * new set.  Now we do a parallel loop through the properties

   547 	 * and emit those marked in the bit vector to the new set.  In

   548 	 * the process, we update the bit vector to actually map from

   549 	 * indices in the old property list to indices in the new

   550 	 * property list for both sets. */

   551 

   552 	merge_properties(merger);

   553 	merge_files(merger);

   554 

   555 	/* Now we loop through the packages again and emit the

   556 	 * property lists, remapped to point to the new properties. */

   557 

   558 	pend = merger->set->packages.data + merger->set->packages.size;

   559 	for (p = merger->set->packages.data; p < pend; p++) {

   560 		struct source *src;

   561 

   562 		if (p->flags & UPSTREAM_SOURCE)

   563 			src = &merger->source2;

   564 		else

   565 			src = &merger->source1;

   566 

   567 		emit_properties(&p->properties,

   568 				&src->set->property_pool,

   569 				src->property_map,

   570 				&merger->set->property_pool);

   571 		emit_files(&p->files,

   572 			   &src->set->file_pool,

   573 			   src->file_map,

   574 			   &merger->set->file_pool);

   575 		p->flags &= ~UPSTREAM_SOURCE;

   576 	}

   577 

   578 	rebuild_property_package_lists(merger->set);

   579 	rebuild_file_package_lists(merger->set);

   580 

   581 	merger->committed = 1;

   582 

   583 	return merger->set;

   584 }

   585 

   586 void

   587 razor_merger_package_add_script(struct razor_merger *merger,

   588 				struct razor_package *package,

   589 				enum razor_property_flags script,

   590 				const char *program, const char *body)

   591 {

   592 	uint32_t p, b;

   593 	char *pool;

   594 	struct razor_set *set = merger->set;

   595 	assert ((void *)package >= set->packages.data && \

   596 	    (void *)package < set->packages.data + set->packages.size);

   597 

   598 	p = hashtable_tokenize(&merger->table, program);

   599 	b = hashtable_tokenize(&merger->table, body);

   600 

   601 	pool = merger->set->string_pool.data;

   602 

   603 	switch (script) {

   604 	case RAZOR_PROPERTY_PREUN:

   605 		if (package->preun.program != p) {

   606 			assert(pool[package->preun.program] == '\0');

   607 			package->preun.program = p;

   608 		}

   609 		if (package->preun.body != b) {

   610 			assert(pool[package->preun.body] == '\0');

   611 			package->preun.body = b;

   612 		}

   613 		break;

   614 	case RAZOR_PROPERTY_POSTUN:

   615 		if (package->postun.program != p) {

   616 			assert(pool[package->postun.program] == '\0');

   617 			package->postun.program = p;

   618 		}

   619 		if (package->postun.body != b) {

   620 			assert(pool[package->postun.body] == '\0');

   621 			package->postun.body = b;

   622 		}

   623 		break;

   624 	default:

   625 		break;

   626 	}

   627 }

   628 

   629 void razor_merger_destroy(struct razor_merger *merger)

   630 {

   631 	hashtable_release(&merger->table);

   632 	hashtable_release(&merger->file_table);

   633 	hashtable_release(&merger->details_table);

   634 	free(merger);

   635 }
razor