Skip to content

bugzilla
bugzilla
Commit 74bcd6f1 authored by gerv%gerv.net's avatar gerv%gerv.net
Browse files
Options

More documentation updates.

parent 62f5b900
Show whitespace changes
Inline Side-by-side
Showing with 5604 additions and 7768 deletions
docs/sgml/administration.sgml
View file @ 74bcd6f1
This source diff could not be displayed because it is too large. You can view the blob instead.
docs/sgml/conventions.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE section PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<section id="conventions">
<title>Document Conventions</title>
......@@ -7,93 +6,151 @@
<primary>conventions</primary>
</indexterm>
<para>
This document uses the following conventions
</para>
<para>This document uses the following conventions</para>
<informaltable frame="none">
<tgroup cols="2">
<thead>
<row>
<entry>Descriptions</entry>
<entry>Appearance</entry>
</row>
</thead>
<tbody>
<row>
<entry>Warnings</entry>
<entry><caution>
<entry>
<caution>
<para>Don't run with scissors!</para>
</caution></entry>
</caution>
</entry>
</row>
<row>
<entry>Hint</entry>
<entry><tip>
<entry>
<tip>
<para>Warm jar lids under the hot tap to loosen them.</para>
</tip></entry>
</tip>
</entry>
</row>
<row>
<entry>Notes</entry>
<entry><note>
<entry>
<note>
<para>Dear John...</para>
</note></entry>
</note>
</entry>
</row>
<row>
<entry>Information requiring special attention</entry>
<entry><warning>
<entry>
<warning>
<para>Read this or the cat gets it.</para>
</warning></entry>
</warning>
</entry>
</row>
<row>
<entry>File Names</entry>
<entry><filename>file.extension</filename></entry>
<entry>
<filename>file.extension</filename>
</entry>
</row>
<row>
<entry>Directory Names</entry>
<entry><filename class="directory">directory</filename></entry>
<entry>
<filename class="directory">directory</filename>
</entry>
</row>
<row>
<entry>Commands to be typed</entry>
<entry><command>command</command></entry>
<entry>
<command>command</command>
</entry>
</row>
<row>
<entry>Applications Names</entry>
<entry><application>application</application></entry>
<entry>
<application>application</application>
</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of users command under bash shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of users command under bash shell</entry>
<entry>bash$</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of root users command under bash shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of root users command under bash shell</entry>
<entry>bash#</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of user command under tcsh shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of user command under tcsh shell</entry>
<entry>tcsh$</entry>
</row>
<row>
<entry>Environment Variables</entry>
<entry><envar>VARIABLE</envar></entry>
<entry>
<envar>VARIABLE</envar>
</entry>
</row>
<row>
<entry>Emphasized word</entry>
<entry><emphasis>word</emphasis></entry>
<entry>
<emphasis>word</emphasis>
</entry>
</row>
<row>
<entry>Code Example</entry>
<entry><programlisting><sgmltag class="starttag">para</sgmltag>Beginning and end of paragraph<sgmltag class="endtag">para</sgmltag></programlisting></entry>
<entry>
<programlisting>
<sgmltag class="starttag">para</sgmltag>
Beginning and end of paragraph
<sgmltag class="endtag">para</sgmltag>
</programlisting>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</section>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -114,3 +171,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/database.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="database">
<title>The Bugzilla Database</title>
<title>The Bugzilla Database</title>
<note>
<para>
This document really needs to be updated with more fleshed out information about primary keys, interrelationships, and maybe some nifty tables to document dependencies. Any takers?
</para>
<note>
<para>This document really needs to be updated with more fleshed out
information about primary keys, interrelationships, and maybe some nifty
tables to document dependencies. Any takers?</para>
</note>
<section id="dbschema">
<title>Database Schema Chart</title>
<para>
<mediaobject>
<imageobject>
......@@ -28,332 +29,285 @@
</section>
<section id="dbdoc">
<title>MySQL Bugzilla Database Introduction</title>
<para>
This information comes straight from my life. I was forced to learn how
Bugzilla organizes database because of nitpicky requests from users for tiny
changes in wording, rather than having people re-educate themselves or
figure out how to work our procedures around the tool. It sucks, but it can
and will happen to you, so learn how the schema works and deal with it when it
comes.
</para>
<para>
So, here you are with your brand-new installation of Bugzilla. You've got
MySQL set up, Apache working right, Perl DBI and DBD talking to the database
flawlessly. Maybe you've even entered a few test bugs to make sure email's
working; people seem to be notified of new bugs and changes, and you can
enter and edit bugs to your heart's content. Perhaps you've gone through the
trouble of setting up a gateway for people to submit bugs to your database via
email, have had a few people test it, and received rave reviews from your beta
testers.
</para>
<para>
What's the next thing you do? Outline a training strategy for your
development team, of course, and bring them up to speed on the new tool you've
labored over for hours.
</para>
<para>
Your first training session starts off very well! You have a captive
audience which seems enraptured by the efficiency embodied in this thing called
"Bugzilla". You are caught up describing the nifty features, how people can
save favorite queries in the database, set them up as headers and footers on
their pages, customize their layouts, generate reports, track status with
greater efficiency than ever before, leap tall buildings with a single bound
and rescue Jane from the clutches of Certain Death!
</para>
<para>
But Certain Death speaks up -- a tiny voice, from the dark corners of the
conference room. "I have a concern," the voice hisses from the darkness,
"about the use of the word 'verified'.
</para>
<para>
The room, previously filled with happy chatter, lapses into reverential
silence as Certain Death (better known as the Vice President of Software
Engineering) continues. "You see, for two years we've used the word 'verified'
to indicate that a developer or quality assurance engineer has confirmed that,
in fact, a bug is valid. I don't want to lose two years of training to a
new software product. You need to change the bug status of 'verified' to
'approved' as soon as possible. To avoid confusion, of course."
</para>
<para>
Oh no! Terror strikes your heart, as you find yourself mumbling "yes, yes, I
don't think that would be a problem," You review the changes with Certain
Death, and continue to jabber on, "no, it's not too big a change. I mean, we
have the source code, right? You know, 'Use the Source, Luke' and all that...
no problem," All the while you quiver inside like a beached jellyfish bubbling,
burbling, and boiling on a hot Jamaican sand dune...
</para>
<para>
Thus begins your adventure into the heart of Bugzilla. You've been forced
to learn about non-portable enum() fields, varchar columns, and tinyint
definitions. The Adventure Awaits You!
</para>
<title>MySQL Bugzilla Database Introduction</title>
<para>This information comes straight from my life. I was forced to learn
how Bugzilla organizes database because of nitpicky requests from users
for tiny changes in wording, rather than having people re-educate
themselves or figure out how to work our procedures around the tool. It
sucks, but it can and will happen to you, so learn how the schema works
and deal with it when it comes.</para>
<para>So, here you are with your brand-new installation of Bugzilla.
You've got MySQL set up, Apache working right, Perl DBI and DBD talking
to the database flawlessly. Maybe you've even entered a few test bugs to
make sure email's working; people seem to be notified of new bugs and
changes, and you can enter and edit bugs to your heart's content. Perhaps
you've gone through the trouble of setting up a gateway for people to
submit bugs to your database via email, have had a few people test it,
and received rave reviews from your beta testers.</para>
<para>What's the next thing you do? Outline a training strategy for your
development team, of course, and bring them up to speed on the new tool
you've labored over for hours.</para>
<para>Your first training session starts off very well! You have a
captive audience which seems enraptured by the efficiency embodied in
this thing called "Bugzilla". You are caught up describing the nifty
features, how people can save favorite queries in the database, set them
up as headers and footers on their pages, customize their layouts,
generate reports, track status with greater efficiency than ever before,
leap tall buildings with a single bound and rescue Jane from the clutches
of Certain Death!</para>
<para>But Certain Death speaks up -- a tiny voice, from the dark corners
of the conference room. "I have a concern," the voice hisses from the
darkness, "about the use of the word 'verified'.</para>
<para>The room, previously filled with happy chatter, lapses into
reverential silence as Certain Death (better known as the Vice President
of Software Engineering) continues. "You see, for two years we've used
the word 'verified' to indicate that a developer or quality assurance
engineer has confirmed that, in fact, a bug is valid. I don't want to
lose two years of training to a new software product. You need to change
the bug status of 'verified' to 'approved' as soon as possible. To avoid
confusion, of course."</para>
<para>Oh no! Terror strikes your heart, as you find yourself mumbling
"yes, yes, I don't think that would be a problem," You review the changes
with Certain Death, and continue to jabber on, "no, it's not too big a
change. I mean, we have the source code, right? You know, 'Use the
Source, Luke' and all that... no problem," All the while you quiver
inside like a beached jellyfish bubbling, burbling, and boiling on a hot
Jamaican sand dune...</para>
<para>Thus begins your adventure into the heart of Bugzilla. You've been
forced to learn about non-portable enum() fields, varchar columns, and
tinyint definitions. The Adventure Awaits You!</para>
<section>
<title>Bugzilla Database Basics</title>
<para>
If you were like me, at this point you're totally clueless
about the internals of MySQL, and if it weren't for this
executive order from the Vice President you couldn't care less
about the difference between a <quote>bigint</quote> and a
<quote>tinyint</quote> entry in MySQL. I recommend you refer
to the MySQL documentation, available at <ulink url="http://www.mysql.com/doc.html">MySQL.com</ulink>. Below are the basics you need to know about the Bugzilla database. Check the chart above for more details.
</para>
<para><orderedlist>
<listitem>
<para>
To connect to your database:
</para>
<para>
<prompt>bash#</prompt><command>mysql</command><parameter>-u root</parameter>
</para>
<para>
If this works without asking you for a password,
<emphasis>shame on you</emphasis>! You should have
locked your security down like the installation
instructions told you to. You can find details on
locking down your database in the Bugzilla FAQ in this
directory (under "Security"), or more robust security
generalities in the MySQL searchable documentation at
http://www.mysql.com/php/manual.php3?section=Privilege_system .
</para>
</listitem>
<listitem>
<para>You should now be at a prompt that looks like
this:</para>
<para><prompt>mysql></prompt></para>
<para>At the prompt, if <quote>bugs</quote> is the name
you chose in the<filename>localconfig</filename> file
for your Bugzilla database, type:</para>
<para><prompt>mysql</prompt><command>use bugs;</command></para>
<note>
<para>Don't forget the <quote>;</quote> at the end of
each line, or you'll be kicking yourself later.</para>
</note>
</listitem>
</orderedlist>
</para>
<section>
<title>Bugzilla Database Tables</title>
<para> Imagine your MySQL database as a series of
spreadsheets, and you won't be too far off. If you use this
command:</para>
<para><prompt>mysql></prompt><command>show tables from bugs;</command></para>
<para>you'll be able to see all the
<quote>spreadsheets</quote> (tables) in your database. It
is similar to a file system, only faster and more robust for
certain types of operations.</para>
<para>From the command issued above, ou should have some
output that looks like this:
<programlisting>
+-------------------+
| Tables in bugs |
+-------------------+
| attachments |
| bugs |
| bugs_activity |
| cc |
| components |
| dependencies |
| fielddefs |
| groups |
| keyworddefs |
| keywords |
| logincookies |
| longdescs |
| milestones |
| namedqueries |
| products |
| profiles |
| profiles_activity |
| shadowlog |
| tokens |
| versions |
| votes |
| watch |
+-------------------+
</programlisting></para>
<literallayout>
Here's an overview of what each table does. Most columns in each table have
descriptive names that make it fairly trivial to figure out their jobs.
attachments: This table stores all attachments to bugs. It tends to be your
largest table, yet also generally has the fewest entries because file
attachments are so (relatively) large.
bugs: This is the core of your system. The bugs table stores most of the
current information about a bug, with the exception of the info stored in the
other tables.
bugs_activity: This stores information regarding what changes are made to bugs
when -- a history file.
cc: This tiny table simply stores all the CC information for any bug which has
any entries in the CC field of the bug. Note that, like most other tables in
Bugzilla, it does not refer to users by their user names, but by their unique
userid, stored as a primary key in the profiles table.
components: This stores the programs and components (or products and
components, in newer Bugzilla parlance) for Bugzilla. Curiously, the "program"
(product) field is the full name of the product, rather than some other unique
identifier, like bug_id and user_id are elsewhere in the database.
dependencies: Stores data about those cool dependency trees.
fielddefs: A nifty table that defines other tables. For instance, when you
submit a form that changes the value of "AssignedTo" this table allows
translation to the actual field name "assigned_to" for entry into MySQL.
groups: defines bitmasks for groups. A bitmask is a number that can uniquely
identify group memberships. For instance, say the group that is allowed to
tweak parameters is assigned a value of "1", the group that is allowed to edit
users is assigned a "2", and the group that is allowed to create new groups is
assigned the bitmask of "4". By uniquely combining the group bitmasks (much
like the chmod command in UNIX,) you can identify a user is allowed to tweak
parameters and create groups, but not edit users, by giving him a bitmask of
"5", or a user allowed to edit users and create groups, but not tweak
parameters, by giving him a bitmask of "6" Simple, huh?
If this makes no sense to you, try this at the mysql prompt:
mysql> select * from groups;
You'll see the list, it makes much more sense that way.
keyworddefs: Definitions of keywords to be used
keywords: Unlike what you'd think, this table holds which keywords are
associated with which bug id's.
logincookies: This stores every login cookie ever assigned to you for every
machine you've ever logged into Bugzilla from. Curiously, it never does any
housecleaning -- I see cookies in this file I've not used for months. However,
since Bugzilla never expires your cookie (for convenience' sake), it makes
sense.
longdescs: The meat of bugzilla -- here is where all user comments are stored!
You've only got 2^24 bytes per comment (it's a mediumtext field), so speak
sparingly -- that's only the amount of space the Old Testament from the Bible
would take (uncompressed, 16 megabytes). Each comment is keyed to the
bug_id to which it's attached, so the order is necessarily chronological, for
comments are played back in the order in which they are received.
milestones: Interesting that milestones are associated with a specific product
in this table, but Bugzilla does not yet support differing milestones by
product through the standard configuration interfaces.
namedqueries: This is where everybody stores their "custom queries". Very
cool feature; it beats the tar out of having to bookmark each cool query you
construct.
products: What products you have, whether new bug entries are allowed for the
product, what milestone you're working toward on that product, votes, etc. It
will be nice when the components table supports these same features, so you
could close a particular component for bug entry without having to close an
entire product...
profiles: Ahh, so you were wondering where your precious user information was
stored? Here it is! With the passwords in plain text for all to see! (but
sshh... don't tell your users!)
profiles_activity: Need to know who did what when to who's profile? This'll
tell you, it's a pretty complete history.
shadowlog: I could be mistaken here, but I believe this table tells you when
your shadow database is updated and what commands were used to update it. We
don't use a shadow database at our site yet, so it's pretty empty for us.
versions: Version information for every product
<para>If you were like me, at this point you're totally clueless about
the internals of MySQL, and if it weren't for this executive order from
the Vice President you couldn't care less about the difference between
a
<quote>bigint</quote>
votes: Who voted for what when
and a
<quote>tinyint</quote>
watch: Who (according to userid) is watching who's bugs (according to their
userid).
entry in MySQL. I recommend you refer to the MySQL documentation,
available at
<ulink url="http://www.mysql.com/doc.html">MySQL.com</ulink>
. Below are the basics you need to know about the Bugzilla database.
Check the chart above for more details.</para>
===
THE DETAILS
===
Ahh, so you're wondering just what to do with the information above? At the
mysql prompt, you can view any information about the columns in a table with
this command (where "table" is the name of the table you wish to view):
mysql> show columns from table;
You can also view all the data in a table with this command:
mysql> select * from table;
<para>
<orderedlist>
<listitem>
<para>To connect to your database:</para>
-- note: this is a very bad idea to do on, for instance, the "bugs" table if
you have 50,000 bugs. You'll be sitting there a while until you ctrl-c or
50,000 bugs play across your screen.
<para>
<prompt>bash#</prompt>
You can limit the display from above a little with the command, where
"column" is the name of the column for which you wish to restrict information:
<command>mysql</command>
mysql> select * from table where (column = "some info");
<parameter>-u root</parameter>
</para>
-- or the reverse of this
<para>If this works without asking you for a password,
<emphasis>shame on you</emphasis>
mysql> select * from table where (column != "some info");
! You should have locked your security down like the installation
instructions told you to. You can find details on locking down
your database in the Bugzilla FAQ in this directory (under
"Security"), or more robust security generalities in the MySQL
searchable documentation at
http://www.mysql.com/php/manual.php3?section=Privilege_system
.</para>
</listitem>
Let's take our example from the introduction, and assume you need to change
the word "verified" to "approved" in the resolution field. We know from the
above information that the resolution is likely to be stored in the "bugs"
table. Note we'll need to change a little perl code as well as this database
change, but I won't plunge into that in this document. Let's verify the
information is stored in the "bugs" table:
<listitem>
<para>You should now be at a prompt that looks like this:</para>
mysql> show columns from bugs
<para>
<prompt>mysql&gt;</prompt>
</para>
(exceedingly long output truncated here)
| bug_status| enum('UNCONFIRMED','NEW','ASSIGNED','REOPENED','RESOLVED','VERIFIED','CLOSED')||MUL | UNCONFIRMED||
<para>At the prompt, if
<quote>bugs</quote>
Sorry about that long line. We see from this that the "bug status" column is
an "enum field", which is a MySQL peculiarity where a string type field can
only have certain types of entries. While I think this is very cool, it's not
standard SQL. Anyway, we need to add the possible enum field entry
'APPROVED' by altering the "bugs" table.
is the name you chose in the
<filename>localconfig</filename>
mysql> ALTER table bugs CHANGE bug_status bug_status
-> enum("UNCONFIRMED", "NEW", "ASSIGNED", "REOPENED", "RESOLVED",
-> "VERIFIED", "APPROVED", "CLOSED") not null;
file for your Bugzilla database, type:</para>
(note we can take three lines or more -- whatever you put in before the
semicolon is evaluated as a single expression)
<para>
<prompt>mysql</prompt>
Now if you do this:
<command>use bugs;</command>
</para>
mysql> show columns from bugs;
<note>
<para>Don't forget the
<quote>;</quote>
you'll see that the bug_status field has an extra "APPROVED" enum that's
available! Cool thing, too, is that this is reflected on your query page as
well -- you can query by the new status. But how's it fit into the existing
scheme of things?
Looks like you need to go back and look for instances of the word "verified"
in the perl code for Bugzilla -- wherever you find "verified", change it to
"approved" and you're in business (make sure that's a case-insensitive search).
Although you can query by the enum field, you can't give something a status
of "APPROVED" until you make the perl changes. Note that this change I
mentioned can also be done by editing checksetup.pl, which automates a lot of
this. But you need to know this stuff anyway, right?
at the end of each line, or you'll be kicking yourself
later.</para>
</note>
</listitem>
</orderedlist>
</para>
I hope this database tutorial has been useful for you. If you have comments
to add, questions, concerns, etc. please direct them to
mbarnson@excitehome.net. Please direct flames to /dev/null :) Have a nice
day!
<section>
<title>Bugzilla Database Tables</title>
<para>Imagine your MySQL database as a series of spreadsheets, and
you won't be too far off. If you use this command:</para>
<para>
<prompt>mysql&gt;</prompt>
===
LINKS
===
<command>show tables from bugs;</command>
</para>
Great MySQL tutorial site:
http://www.devshed.com/Server_Side/MySQL/
<para>you'll be able to see all the
<quote>spreadsheets</quote>
(tables) in your database. It is similar to a file system, only
faster and more robust for certain types of operations.</para>
<para>From the command issued above, ou should have some output that
looks like this:
<programlisting>+-------------------+ | Tables in bugs |
+-------------------+ | attachments | | bugs | | bugs_activity | | cc
| | components | | dependencies | | fielddefs | | groups | |
keyworddefs | | keywords | | logincookies | | longdescs | |
milestones | | namedqueries | | products | | profiles | |
profiles_activity | | shadowlog | | tokens | | versions | | votes | |
watch | +-------------------+</programlisting>
</para>
</literallayout>
<literallayout>Here's an overview of what each table does. Most
columns in each table have descriptive names that make it fairly
trivial to figure out their jobs. attachments: This table stores all
attachments to bugs. It tends to be your largest table, yet also
generally has the fewest entries because file attachments are so
(relatively) large. bugs: This is the core of your system. The bugs
table stores most of the current information about a bug, with the
exception of the info stored in the other tables. bugs_activity: This
stores information regarding what changes are made to bugs when -- a
history file. cc: This tiny table simply stores all the CC
information for any bug which has any entries in the CC field of the
bug. Note that, like most other tables in Bugzilla, it does not refer
to users by their user names, but by their unique userid, stored as a
primary key in the profiles table. components: This stores the
programs and components (or products and components, in newer
Bugzilla parlance) for Bugzilla. Curiously, the "program" (product)
field is the full name of the product, rather than some other unique
identifier, like bug_id and user_id are elsewhere in the database.
dependencies: Stores data about those cool dependency trees.
fielddefs: A nifty table that defines other tables. For instance,
when you submit a form that changes the value of "AssignedTo" this
table allows translation to the actual field name "assigned_to" for
entry into MySQL. groups: defines bitmasks for groups. A bitmask is a
number that can uniquely identify group memberships. For instance,
say the group that is allowed to tweak parameters is assigned a value
of "1", the group that is allowed to edit users is assigned a "2",
and the group that is allowed to create new groups is assigned the
bitmask of "4". By uniquely combining the group bitmasks (much like
the chmod command in UNIX,) you can identify a user is allowed to
tweak parameters and create groups, but not edit users, by giving him
a bitmask of "5", or a user allowed to edit users and create groups,
but not tweak parameters, by giving him a bitmask of "6" Simple, huh?
If this makes no sense to you, try this at the mysql prompt:
mysql&gt; select * from groups; You'll see the list, it makes much
more sense that way. keyworddefs: Definitions of keywords to be used
keywords: Unlike what you'd think, this table holds which keywords
are associated with which bug id's. logincookies: This stores every
login cookie ever assigned to you for every machine you've ever
logged into Bugzilla from. Curiously, it never does any housecleaning
-- I see cookies in this file I've not used for months. However,
since Bugzilla never expires your cookie (for convenience' sake), it
makes sense. longdescs: The meat of bugzilla -- here is where all
user comments are stored! You've only got 2^24 bytes per comment
(it's a mediumtext field), so speak sparingly -- that's only the
amount of space the Old Testament from the Bible would take
(uncompressed, 16 megabytes). Each comment is keyed to the bug_id to
which it's attached, so the order is necessarily chronological, for
comments are played back in the order in which they are received.
milestones: Interesting that milestones are associated with a
specific product in this table, but Bugzilla does not yet support
differing milestones by product through the standard configuration
interfaces. namedqueries: This is where everybody stores their
"custom queries". Very cool feature; it beats the tar out of having
to bookmark each cool query you construct. products: What products
you have, whether new bug entries are allowed for the product, what
milestone you're working toward on that product, votes, etc. It will
be nice when the components table supports these same features, so
you could close a particular component for bug entry without having
to close an entire product... profiles: Ahh, so you were wondering
where your precious user information was stored? Here it is! With the
passwords in plain text for all to see! (but sshh... don't tell your
users!) profiles_activity: Need to know who did what when to who's
profile? This'll tell you, it's a pretty complete history. shadowlog:
I could be mistaken here, but I believe this table tells you when
your shadow database is updated and what commands were used to update
it. We don't use a shadow database at our site yet, so it's pretty
empty for us. versions: Version information for every product votes:
Who voted for what when watch: Who (according to userid) is watching
who's bugs (according to their userid). === THE DETAILS === Ahh, so
you're wondering just what to do with the information above? At the
mysql prompt, you can view any information about the columns in a
table with this command (where "table" is the name of the table you
wish to view): mysql&gt; show columns from table; You can also view
all the data in a table with this command: mysql&gt; select * from
table; -- note: this is a very bad idea to do on, for instance, the
"bugs" table if you have 50,000 bugs. You'll be sitting there a while
until you ctrl-c or 50,000 bugs play across your screen. You can
limit the display from above a little with the command, where
"column" is the name of the column for which you wish to restrict
information: mysql&gt; select * from table where (column = "some
info"); -- or the reverse of this mysql&gt; select * from table where
(column != "some info"); Let's take our example from the
introduction, and assume you need to change the word "verified" to
"approved" in the resolution field. We know from the above
information that the resolution is likely to be stored in the "bugs"
table. Note we'll need to change a little perl code as well as this
database change, but I won't plunge into that in this document. Let's
verify the information is stored in the "bugs" table: mysql&gt; show
columns from bugs (exceedingly long output truncated here) |
bug_status|
enum('UNCONFIRMED','NEW','ASSIGNED','REOPENED','RESOLVED','VERIFIED','CLOSED')||MUL
| UNCONFIRMED|| Sorry about that long line. We see from this that the
"bug status" column is an "enum field", which is a MySQL peculiarity
where a string type field can only have certain types of entries.
While I think this is very cool, it's not standard SQL. Anyway, we
need to add the possible enum field entry 'APPROVED' by altering the
"bugs" table. mysql&gt; ALTER table bugs CHANGE bug_status bug_status
-&gt; enum("UNCONFIRMED", "NEW", "ASSIGNED", "REOPENED", "RESOLVED",
-&gt; "VERIFIED", "APPROVED", "CLOSED") not null; (note we can take
three lines or more -- whatever you put in before the semicolon is
evaluated as a single expression) Now if you do this: mysql&gt; show
columns from bugs; you'll see that the bug_status field has an extra
"APPROVED" enum that's available! Cool thing, too, is that this is
reflected on your query page as well -- you can query by the new
status. But how's it fit into the existing scheme of things? Looks
like you need to go back and look for instances of the word
"verified" in the perl code for Bugzilla -- wherever you find
"verified", change it to "approved" and you're in business (make sure
that's a case-insensitive search). Although you can query by the enum
field, you can't give something a status of "APPROVED" until you make
the perl changes. Note that this change I mentioned can also be done
by editing checksetup.pl, which automates a lot of this. But you need
to know this stuff anyway, right? I hope this database tutorial has
been useful for you. If you have comments to add, questions,
concerns, etc. please direct them to mbarnson@excitehome.net. Please
direct flames to /dev/null :) Have a nice day! === LINKS === Great
MySQL tutorial site:
http://www.devshed.com/Server_Side/MySQL/</literallayout>
</section>
</section>
</section>
......@@ -362,192 +316,126 @@ http://www.devshed.com/Server_Side/MySQL/
<title>MySQL Permissions &amp; Grant Tables</title>
<note>
<para>The following portion of documentation comes from my
answer to an old discussion of Keystone, a cool product that
does trouble-ticket tracking for IT departments. I wrote this
post to the Keystone support group regarding MySQL grant
table permissions, and how to use them effectively. It is
badly in need of updating, as I believe MySQL has added a
field or two to the grant tables since this time, but it
serves as a decent introduction and troubleshooting document
for grant table issues. I used Keynote to track my troubles
until I discovered Bugzilla, which gave me a whole new set of
troubles to work on : ) Although it is of limited use, it
still has SOME use, thus it's still included.</para>
<para>
Please note, however, that I was a relatively new user to
MySQL at the time. Some of my suggestions, particularly in
how to set up security, showed a terrible lack of
security-related database experience.
</para>
<para>The following portion of documentation comes from my answer to an
old discussion of Keystone, a cool product that does trouble-ticket
tracking for IT departments. I wrote this post to the Keystone support
group regarding MySQL grant table permissions, and how to use them
effectively. It is badly in need of updating, as I believe MySQL has
added a field or two to the grant tables since this time, but it serves
as a decent introduction and troubleshooting document for grant table
issues. I used Keynote to track my troubles until I discovered
Bugzilla, which gave me a whole new set of troubles to work on : )
Although it is of limited use, it still has SOME use, thus it's still
included.</para>
<para>Please note, however, that I was a relatively new user to MySQL
at the time. Some of my suggestions, particularly in how to set up
security, showed a terrible lack of security-related database
experience.</para>
</note>
<literallayout>
From matt_barnson@singletrac.com Wed Jul 7 09:00:07 1999
Date: Mon, 1 Mar 1999 21:37:04 -0700
From: Matthew Barnson matt_barnson@singletrac.com
To: keystone-users@homeport.org
Subject: [keystone-users] Grant Tables FAQ
[The following text is in the "iso-8859-1" character set]
[Your display is set for the "US-ASCII" character set]
[Some characters may be displayed incorrectly]
Maybe we can include this rambling message in the Keystone FAQ? It gets
asked a lot, and the only option current listed in the FAQ is
"--skip-grant-tables".
Really, you can't go wrong by reading section 6 of the MySQL manual, at
http://www.mysql.com/Manual/manual.html. I am sure their description is
better than mine.
MySQL runs fine without permissions set up correctly if you run the mysql
daemon with the "--skip-grant-tables" option. Running this way denies
access to nobody. Unfortunately, unless you've got yourself firewalled it
also opens the potential for abuse if someone knows you're running it.
Additionally, the default permissions for MySQL allow anyone at localhost
access to the database if the database name begins with "test_" or is named
"test" (i.e. "test_keystone"). You can change the name of your database in
the keystone.conf file ($sys_dbname). This is the way I am doing it for
some of my databases, and it works fine.
The methods described below assume you're running MySQL on the same box as
your webserver, and that you don't mind if your $sys_dbuser for Keystone has
superuser access. See near the bottom of this message for a description of
what each field does.
Method #1:
1. cd /var/lib
#location where you'll want to run /usr/bin/mysql_install_db shell
script from to get it to work.
2. ln -s mysql data
# soft links the "mysql" directory to "data", which is what
mysql_install_db expects. Alternately, you can edit mysql_install_db and
change all the "./data" references to "./mysql".
3. Edit /usr/bin/mysql_install_db with your favorite text editor (vi,
emacs, jot, pico, etc.)
A) Copy the "INSERT INTO db VALUES
('%','test\_%','','Y','Y','Y','Y','Y','Y');" and paste it immediately after
itself. Chage the 'test\_%' value to 'keystone', or the value of
$sys_dbname in keystone.conf.
B) If you are running your keystone database with any user, you'll need to
copy the "INSERT INTO user VALUES
('localhost','root','','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');" line after
itself and change 'root' to the name of the keystone database user
($sys_dbuser) in keystone.conf.
# adds entries to the script to create grant tables for specific
hosts and users. The user you set up has super-user access ($sys_dbuser) --
you may or may not want this. The layout of mysql_install_db is really very
uncomplicated.
4. /usr/bin/mysqladmin shutdown
# ya gotta shut it down before you can reinstall the grant tables!
5. rm -i /var/lib/mysql/mysql/*.IS?' and answer 'Y' to the deletion
questions.
# nuke your current grant tables. This WILL NOT delete any other
databases than your grant tables.
6. /usr/bin/mysql_install_db
# run the script you just edited to install your new grant tables.
7. mysqladmin -u root password (new_password)
# change the root MySQL password, or else anyone on localhost can
login to MySQL as root and make changes. You can skip this step if you want
keystone to connect as root with no password.
8. mysqladmin -u (webserver_user_name) password (new_password)
# change the password of the $sys_dbuser. Note that you will need
to change the password in the keystone.conf file as well in $sys_dbpasswd,
and if your permissions are set up incorrectly anybody can type the URL to
your keystone.conf file and get the password. Not that this will help them
much if your permissions are set to @localhost.
Method #2: easier, but a pain reproducing if you have to delete your grant
tables. This is the "recommended" method for altering grant tables in
MySQL. I don't use it because I like the other way :)
shell> mysql --user=root keystone
mysql> GRANT
SELECT,INSERT,UPDATE,DELETE,INDEX,ALTER,CREATE,DROP,RELOAD,SHUTDOWN,PROCESS,
FILE,
ON keystone.*
TO &lt;$sys_dbuser name>@localhost
IDENTIFIED BY '(password)'
WITH GRANT OPTION;
OR
mysql> GRANT ALL PRIVILEGES
ON keystone.*
TO &lt;$sys_dbuser name>@localhost
IDENTIFIED BY '(password)'
WITH GRANT OPTION;
# this grants the required permissions to the keystone ($sys_dbuser)
account defined in keystone.conf. However, if you are runnning many
different MySQL-based apps, as we are, it's generally better to edit the
mysql_install_db script to be able to quickly reproduce your permissions
structure again. Note that the FILE privelege and WITH GRANT OPTION may not
be in your best interest to include.
GRANT TABLE FIELDS EXPLANATION:
Quick syntax summary: "%" in MySQL is a wildcard. I.E., if you are
defining your DB table and in the 'host' field and enter '%', that means
that any host can access that database. Of course, that host must also have
a valid db user in order to do anything useful. 'db'=name of database. In
our case, it should be "keystone". "user" should be your "$sys_dbuser"
defined in keystone.conf. Note that you CANNOT add or change a password by
using the "INSERT INTO db (X)" command -- you must change it with the mysql
-u command as defined above. Passwords are stored encrypted in the MySQL
database, and if you try to enter it directly into the table they will not
match.
TABLE: USER. Everything after "password" is a privelege granted (Y/N).
This table controls individual user global access rights.
'host','user','password','select','insert','update','delete','index','alter'
,'create','drop','grant','reload','shutdown','process','file'
TABLE: DB. This controls access of USERS to databases.
'host','db','user','select','insert','update','delete','index','alter','crea
te','drop','grant'
TABLE: HOST. This controls which HOSTS are allowed what global access
rights. Note that the HOST table, USER table, and DB table are very closely
connected -- if an authorized USER attempts an SQL request from an
unauthorized HOST, she's denied. If a request from an authorized HOST is
not an authorized USER, it is denied. If a globally authorized USER does
not have rights to a certain DB, she's denied. Get the picture?
'host','db','select','insert','update','delete','index','alter','create','dr
op','grant'
You should now have a working knowledge of MySQL grant tables. If there is
anything I've left out of this answer that you feel is pertinent, or if my
instructions don't work for you, please let me know and I'll re-post this
letter again, corrected. I threw it together one night out of exasperation
for all the newbies who don't know squat about MySQL yet, so it is almost
guaranteed to have errors.
Once again, you can't go wrong by reading section 6 of the MySQL manual. It
is more detailed than I!
http://www.mysql.com/Manual/manual.html.
</literallayout>
<literallayout>From matt_barnson@singletrac.com Wed Jul 7 09:00:07 1999
Date: Mon, 1 Mar 1999 21:37:04 -0700 From: Matthew Barnson
matt_barnson@singletrac.com To: keystone-users@homeport.org Subject:
[keystone-users] Grant Tables FAQ [The following text is in the
"iso-8859-1" character set] [Your display is set for the "US-ASCII"
character set] [Some characters may be displayed incorrectly] Maybe we
can include this rambling message in the Keystone FAQ? It gets asked a
lot, and the only option current listed in the FAQ is
"--skip-grant-tables". Really, you can't go wrong by reading section 6 of
the MySQL manual, at http://www.mysql.com/Manual/manual.html. I am sure
their description is better than mine. MySQL runs fine without
permissions set up correctly if you run the mysql daemon with the
"--skip-grant-tables" option. Running this way denies access to nobody.
Unfortunately, unless you've got yourself firewalled it also opens the
potential for abuse if someone knows you're running it. Additionally, the
default permissions for MySQL allow anyone at localhost access to the
database if the database name begins with "test_" or is named "test"
(i.e. "test_keystone"). You can change the name of your database in the
keystone.conf file ($sys_dbname). This is the way I am doing it for some
of my databases, and it works fine. The methods described below assume
you're running MySQL on the same box as your webserver, and that you
don't mind if your $sys_dbuser for Keystone has superuser access. See
near the bottom of this message for a description of what each field
does. Method #1: 1. cd /var/lib #location where you'll want to run
/usr/bin/mysql_install_db shell script from to get it to work. 2. ln -s
mysql data # soft links the "mysql" directory to "data", which is what
mysql_install_db expects. Alternately, you can edit mysql_install_db and
change all the "./data" references to "./mysql". 3. Edit
/usr/bin/mysql_install_db with your favorite text editor (vi, emacs, jot,
pico, etc.) A) Copy the "INSERT INTO db VALUES
('%','test\_%','','Y','Y','Y','Y','Y','Y');" and paste it immediately
after itself. Chage the 'test\_%' value to 'keystone', or the value of
$sys_dbname in keystone.conf. B) If you are running your keystone
database with any user, you'll need to copy the "INSERT INTO user VALUES
('localhost','root','','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');" line
after itself and change 'root' to the name of the keystone database user
($sys_dbuser) in keystone.conf. # adds entries to the script to create
grant tables for specific hosts and users. The user you set up has
super-user access ($sys_dbuser) -- you may or may not want this. The
layout of mysql_install_db is really very uncomplicated. 4.
/usr/bin/mysqladmin shutdown # ya gotta shut it down before you can
reinstall the grant tables! 5. rm -i /var/lib/mysql/mysql/*.IS?' and
answer 'Y' to the deletion questions. # nuke your current grant tables.
This WILL NOT delete any other databases than your grant tables. 6.
/usr/bin/mysql_install_db # run the script you just edited to install
your new grant tables. 7. mysqladmin -u root password (new_password) #
change the root MySQL password, or else anyone on localhost can login to
MySQL as root and make changes. You can skip this step if you want
keystone to connect as root with no password. 8. mysqladmin -u
(webserver_user_name) password (new_password) # change the password of
the $sys_dbuser. Note that you will need to change the password in the
keystone.conf file as well in $sys_dbpasswd, and if your permissions are
set up incorrectly anybody can type the URL to your keystone.conf file
and get the password. Not that this will help them much if your
permissions are set to @localhost. Method #2: easier, but a pain
reproducing if you have to delete your grant tables. This is the
"recommended" method for altering grant tables in MySQL. I don't use it
because I like the other way :) shell&gt; mysql --user=root keystone
mysql&gt; GRANT
SELECT,INSERT,UPDATE,DELETE,INDEX,ALTER,CREATE,DROP,RELOAD,SHUTDOWN,PROCESS,
FILE, ON keystone.* TO &lt;$sys_dbuser name&gt;@localhost IDENTIFIED BY
'(password)' WITH GRANT OPTION; OR mysql&gt; GRANT ALL PRIVILEGES ON
keystone.* TO &lt;$sys_dbuser name&gt;@localhost IDENTIFIED BY
'(password)' WITH GRANT OPTION; # this grants the required permissions to
the keystone ($sys_dbuser) account defined in keystone.conf. However, if
you are runnning many different MySQL-based apps, as we are, it's
generally better to edit the mysql_install_db script to be able to
quickly reproduce your permissions structure again. Note that the FILE
privelege and WITH GRANT OPTION may not be in your best interest to
include. GRANT TABLE FIELDS EXPLANATION: Quick syntax summary: "%" in
MySQL is a wildcard. I.E., if you are defining your DB table and in the
'host' field and enter '%', that means that any host can access that
database. Of course, that host must also have a valid db user in order to
do anything useful. 'db'=name of database. In our case, it should be
"keystone". "user" should be your "$sys_dbuser" defined in keystone.conf.
Note that you CANNOT add or change a password by using the "INSERT INTO
db (X)" command -- you must change it with the mysql -u command as
defined above. Passwords are stored encrypted in the MySQL database, and
if you try to enter it directly into the table they will not match.
TABLE: USER. Everything after "password" is a privelege granted (Y/N).
This table controls individual user global access rights.
'host','user','password','select','insert','update','delete','index','alter'
,'create','drop','grant','reload','shutdown','process','file' TABLE: DB.
This controls access of USERS to databases.
'host','db','user','select','insert','update','delete','index','alter','crea
te','drop','grant' TABLE: HOST. This controls which HOSTS are allowed
what global access rights. Note that the HOST table, USER table, and DB
table are very closely connected -- if an authorized USER attempts an SQL
request from an unauthorized HOST, she's denied. If a request from an
authorized HOST is not an authorized USER, it is denied. If a globally
authorized USER does not have rights to a certain DB, she's denied. Get
the picture?
'host','db','select','insert','update','delete','index','alter','create','dr
op','grant' You should now have a working knowledge of MySQL grant
tables. If there is anything I've left out of this answer that you feel
is pertinent, or if my instructions don't work for you, please let me
know and I'll re-post this letter again, corrected. I threw it together
one night out of exasperation for all the newbies who don't know squat
about MySQL yet, so it is almost guaranteed to have errors. Once again,
you can't go wrong by reading section 6 of the MySQL manual. It is more
detailed than I! http://www.mysql.com/Manual/manual.html.</literallayout>
</section>
</appendix>
<!-- Keep this comment at the end of the file
......@@ -570,3 +458,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/dbschema.mysql
View file @ 74bcd6f1
# MySQL dump 7.1
#
# Host: localhost Database: bugs
#--------------------------------------------------------
# Server version 3.22.32
#
# Table structure for table 'attachments'
#
CREATE TABLE attachments (
attach_id mediumint(9) DEFAULT '0' NOT NULL auto_increment,
bug_id mediumint(9) DEFAULT '0' NOT NULL,
creation_ts timestamp(14),
description mediumtext NOT NULL,
mimetype mediumtext NOT NULL,
ispatch tinyint(4),
filename mediumtext NOT NULL,
thedata longblob NOT NULL,
submitter_id mediumint(9) DEFAULT '0' NOT NULL,
PRIMARY KEY (attach_id)
);
create index index_41 on attachments (bug_id);
create index index_42 on attachments (creation_ts);
#
# Table structure for table 'bugs'
#
CREATE TABLE bugs (
bug_id mediumint(9) DEFAULT '0' NOT NULL auto_increment,
groupset bigint(20) DEFAULT '0' NOT NULL,
assigned_to mediumint(9) DEFAULT '0' NOT NULL,
bug_file_loc text,
bug_severity enum DEFAULT 'blocker' NOT NULL,
bug_status enum DEFAULT 'UNCONFIRMED' NOT NULL,
creation_ts datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
delta_ts timestamp(14),
short_desc mediumtext,
op_sys enum DEFAULT 'All' NOT NULL,
priority enum DEFAULT 'P1' NOT NULL,
product varchar(64) DEFAULT '' NOT NULL,
rep_platform enum,
reporter mediumint(9) DEFAULT '0' NOT NULL,
version varchar(16) DEFAULT '' NOT NULL,
component varchar(50) DEFAULT '' NOT NULL,
resolution enum DEFAULT '' NOT NULL,
target_milestone varchar(20) DEFAULT '---' NOT NULL,
qa_contact mediumint(9) DEFAULT '0' NOT NULL,
status_whiteboard mediumtext NOT NULL,
votes mediumint(9) DEFAULT '0' NOT NULL,
keywords mediumtext NOT NULL,
lastdiffed datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
everconfirmed tinyint(4) DEFAULT '0' NOT NULL,
PRIMARY KEY (bug_id)
);
create index index_7 on bugs (assigned_to);
create index index_8 on bugs (creation_ts);
create index index_9 on bugs (delta_ts);
create index index_10 on bugs (bug_severity);
create index index_11 on bugs (bug_status);
create index index_12 on bugs (op_sys);
create index index_13 on bugs (priority);
create index index_14 on bugs (product);
create index index_15 on bugs (reporter);
create index index_16 on bugs (version);
create index index_17 on bugs (component);
create index index_18 on bugs (resolution);
create index index_19 on bugs (target_milestone);
create index index_20 on bugs (qa_contact);
create index index_21 on bugs (votes);
#
# Table structure for table 'bugs_activity'
#
CREATE TABLE bugs_activity (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
bug_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
fieldid mediumint(9) DEFAULT '0' NOT NULL,
oldvalue tinytext,
newvalue tinytext
);
create index index_43 on bugs_activity (bug_id);
create index index_44 on bugs_activity (bug_when);
create index index_45 on bugs_activity (fieldid);
#
# Table structure for table 'cc'
#
CREATE TABLE cc (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL
);
create index index_31 on cc (who);
create unique index index_32 on cc (bug_id,who);
#
# Table structure for table 'components'
#
CREATE TABLE components (
value tinytext,
program varchar(64),
initialowner tinytext NOT NULL,
initialqacontact tinytext NOT NULL,
description mediumtext NOT NULL
);
#
# Table structure for table 'dependencies'
#
CREATE TABLE dependencies (
blocked mediumint(9) DEFAULT '0' NOT NULL,
dependson mediumint(9) DEFAULT '0' NOT NULL
);
create index index_34 on dependencies (blocked);
create index index_35 on dependencies (dependson);
#
# Table structure for table 'duplicates'
#
CREATE TABLE duplicates (
dupe_of mediumint(9) DEFAULT '0' NOT NULL,
dupe mediumint(9) DEFAULT '0' NOT NULL,
PRIMARY KEY (dupe)
);
#
# Table structure for table 'fielddefs'
#
CREATE TABLE fielddefs (
fieldid mediumint(9) DEFAULT '0' NOT NULL auto_increment,
name varchar(64) DEFAULT '' NOT NULL,
description mediumtext NOT NULL,
mailhead tinyint(4) DEFAULT '0' NOT NULL,
sortkey smallint(6) DEFAULT '0' NOT NULL,
PRIMARY KEY (fieldid)
);
create unique index index_28 on fielddefs (name);
create index index_29 on fielddefs (sortkey);
#
# Table structure for table 'groups'
#
CREATE TABLE groups (
bit bigint(20) DEFAULT '0' NOT NULL,
name varchar(255) DEFAULT '' NOT NULL,
description text NOT NULL,
isbuggroup tinyint(4) DEFAULT '0' NOT NULL,
userregexp tinytext NOT NULL
);
create unique index index_3 on groups (bit);
create unique index index_4 on groups (name);
#
# Table structure for table 'keyworddefs'
#
CREATE TABLE keyworddefs (
id smallint(6) DEFAULT '0' NOT NULL,
name varchar(64) DEFAULT '' NOT NULL,
description mediumtext,
PRIMARY KEY (id)
);
create unique index index_33 on keyworddefs (name);
#
# Table structure for table 'keywords'
#
CREATE TABLE keywords (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
keywordid smallint(6) DEFAULT '0' NOT NULL
);
create index index_39 on keywords (keywordid);
create unique index index_40 on keywords (bug_id, keywordid);
#
# Table structure for table 'logincookies'
#
CREATE TABLE logincookies (
cookie mediumint(9) DEFAULT '0' NOT NULL auto_increment,
userid mediumint(9) DEFAULT '0' NOT NULL,
cryptpassword varchar(64),
hostname varchar(128),
lastused timestamp(14),
PRIMARY KEY (cookie)
);
create index index_30 on logincookies (lastused);
#
# Table structure for table 'longdescs'
#
CREATE TABLE longdescs (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
bug_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
thetext mediumtext
);
create index index_22 on longdescs (bug_id);
create index index_23 on longdescs (bug_when);
#
# Table structure for table 'milestones'
#
CREATE TABLE milestones (
value varchar(20) DEFAULT '' NOT NULL,
product varchar(64) DEFAULT '' NOT NULL,
sortkey smallint(6) DEFAULT '0' NOT NULL,
);
create unique index index_24 on milestones (product, value);
#
# Table structure for table 'namedqueries'
#
CREATE TABLE namedqueries (
userid mediumint(9) DEFAULT '0' NOT NULL,
name varchar(64) DEFAULT '' NOT NULL,
watchfordiffs tinyint(4) DEFAULT '0' NOT NULL,
linkinfooter tinyint(4) DEFAULT '0' NOT NULL,
query mediumtext NOT NULL
);
create unique index index_25 on namedqueries (userid, name);
create index index_26 on namedqueries (watchfordiffs);
#
# Table structure for table 'products'
#
CREATE TABLE products (
product varchar(64),
description mediumtext,
milestoneurl tinytext NOT NULL,
disallownew tinyint(4) DEFAULT '0' NOT NULL,
votesperuser smallint(6) DEFAULT '0' NOT NULL,
maxvotesperbug smallint(6) DEFAULT '10000' NOT NULL,
votestoconfirm smallint(6) DEFAULT '0' NOT NULL,
defaultmilestone varchar(20) DEFAULT '---' NOT NULL
);
#
# Table structure for table 'profiles'
#
CREATE TABLE profiles (
userid mediumint(9) DEFAULT '0' NOT NULL auto_increment,
login_name varchar(255) DEFAULT '' NOT NULL,
password varchar(16),
cryptpassword varchar(64),
realname varchar(255),
groupset bigint(20) DEFAULT '0' NOT NULL,
emailnotification enum DEFAULT 'ExcludeSelfChanges' NOT NULL,
disabledtext mediumtext NOT NULL,
newemailtech tinyint(4) DEFAULT '0' NOT NULL,
mybugslink tinyint(4) DEFAULT '1' NOT NULL,
blessgroupset bigint(20) DEFAULT '0' NOT NULL,
PRIMARY KEY (userid)
);
create unique index index_27 on profiles (login_name);
#
# Table structure for table 'profiles_activity'
#
CREATE TABLE profiles_activity (
userid mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
profiles_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
fieldid mediumint(9) DEFAULT '0' NOT NULL,
oldvalue tinytext,
newvalue tinytext
);
create index index_0 on profiles_activity (userid);
create index index_1 on profiles_activity (profiles_when);
create index index_2 on profiles_activity (fieldid);
#
# Table structure for table 'shadowlog'
#
CREATE TABLE shadowlog (
id int(11) DEFAULT '0' NOT NULL auto_increment,
ts timestamp(14),
reflected tinyint(4) DEFAULT '0' NOT NULL,
command mediumtext NOT NULL,
PRIMARY KEY (id)
);
create index index_38 on shadowlog (reflected);
#
# Table structure for table 'versions'
#
CREATE TABLE versions (
value tinytext,
program varchar(64) DEFAULT '' NOT NULL
);
#
# Table structure for table 'votes'
#
CREATE TABLE votes (
who mediumint(9) DEFAULT '0' NOT NULL,
bug_id mediumint(9) DEFAULT '0' NOT NULL,
count smallint(6) DEFAULT '0' NOT NULL
);
create index index_5 on votes (who);
create index index_6 on votes (bug_id);
#
# Table structure for table 'watch'
#
CREATE TABLE watch (
watcher mediumint(9) DEFAULT '0' NOT NULL,
watched mediumint(9) DEFAULT '0' NOT NULL
);
create index index_36 on watch (watched);
create unique index index_37 on watch (watcher, watched);
docs/sgml/faq.sgml
View file @ 74bcd6f1
......@@ -17,8 +17,8 @@
<answer>
<para>
You can stay up-to-date with the latest Bugzilla
information at <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink>
information at <ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink>
</para>
</answer>
</qandaentry>
......@@ -54,7 +54,7 @@
<para>
There are several experienced
Bugzilla hackers on the mailing list/newsgroup who are willing
to whore themselves out for generous compensation.
to make themselves available for generous compensation.
Try sending a message to the mailing list asking for a volunteer.
</para>
</answer>
......@@ -74,12 +74,11 @@
<simplelist>
<member>Netscape/AOL</member>
<member>Mozilla.org</member>
<member>NASA</member>
<member>AtHome Corporation</member>
<member>Red Hat Software</member>
<member>Loki Entertainment Software</member>
<member>SuSe Corp</member>
<member>The Horde Project</member>
<member>The Eazel Project</member>
<member>AbiSource</member>
<member>Real Time Enterprises, Inc</member>
<member>Eggheads.org</member>
......@@ -88,6 +87,7 @@
<member>Creative Labs (makers of SoundBlaster)</member>
<member>The Apache Foundation</member>
<member>The Gnome Foundation</member>
<member>Ximian</member>
<member>Linux-Mandrake</member>
</simplelist>
</para>
......@@ -106,9 +106,9 @@
</question>
<answer>
<para>
Bugzilla maintenance has been in a state of flux recently.
Please check <ulink
url="http://www.mozilla.org/projects/bugzilla/">the Bugzilla Project Page for the latest details. </ulink>
A
<ulink url="http://www.bugzilla.org/who_we_are.html">core team</ulink>,
led by Dave Miller (justdave@syndicomm.com).
</para>
</answer>
</qandaentry>
......@@ -144,13 +144,13 @@
<qandaentry>
<question>
<para>
How do I change my user name in Bugzilla?
How do I change my user name (email address) in Bugzilla?
</para>
</question>
<answer>
<para>
You can't. However, the administrative account can, by simply opening
your user account in editusers.cgi and changing the login name.
New in 2.16 - go to the Account section of the Preferences. You will
be emailed at both addresses for confirmation.
</para>
</answer>
</qandaentry>
......@@ -175,7 +175,7 @@
You can help the project along by either hacking a patch yourself
that supports the functionality you require, or else submitting a
"Request for Enhancement" (RFE) using the bug submission interface
at <ulink url="http://bugzilla.mozilla.org/">bugzilla.mozilla.org</ulink>.
at <ulink url="http://bugzilla.mozilla.org/enter_bug.cgi?product=Bugzilla">bugzilla.mozilla.org</ulink>.
</para>
</answer>
</qandaentry>
......@@ -188,42 +188,10 @@
</para>
</question>
<answer>
<para>Terry Weissman answers,
<blockquote>
<para>
You're not the only one. But <emphasis>I</emphasis> am not very interested. I'm not
a real SQL or database person. I just wanted to make a useful tool,
and build it on top of free software. So, I picked MySQL, and
learned SQL by staring at the MySQL manual and some code lying
around here, and
wrote Bugzilla. I didn't know that Enum's were non-standard SQL.
I'm not sure if I would have cared, but I didn't even know. So, to
me, things are "portable" because it uses MySQL, and MySQL is
portable enough. I fully understand (now) that people want to be
portable to other databases, but that's never been a real concern
of mine.
</para>
</blockquote>
</para>
<para>
Things aren't quite that grim these days, however. Terry pretty much
sums up much of the thinking many of us have for Bugzilla, but there
is light on the horizon for database-independence! Here are some options:
There is DB-independence work afoot. PostgreSQL support is planned
for 2.18, and full DB-independence can't be far further on.
</para>
<simplelist>
<member>
<emphasis><ulink url="http://bugzilla.redhat.com/">Red Hat Bugzilla</ulink></emphasis>:
Runs a modified Bugzilla 2.8 atop an Oracle database.
</member>
<member>
<emphasis><ulink url="http://sourceforge.net/projects/interzilla">Interzilla</ulink></emphasis>:
A project to run Bugzilla on Interbase. No code released yet, however.
</member>
<member>
<emphasis>Bugzilla 3.0</emphasis>: One of the primary stated goals
is multiple database support.
</member>
</simplelist>
</answer>
</qandaentry>
......@@ -257,10 +225,6 @@
of perl to /usr/bonsaitools/bin/perl. This will make upgrading
your Bugzilla much easier in the future.
</para>
<para>
Obviously, if you do not have root access to your Bugzilla
box, our suggestion is irrelevant.
</para>
</note>
</blockquote>
</para>
......@@ -269,252 +233,6 @@
</qandadiv>
<qandadiv id="faq-redhat">
<title>Red Hat Bugzilla</title>
<para>
<note>
<para>
<emphasis>This section is no longer up-to-date.</emphasis>
Please see the section on "Red Hat Bugzilla" under "Variants" in The Bugzilla Guide.
</para>
</note>
</para>
<qandaentry>
<question>
<para>
What about Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
Red Hat Bugzilla is arguably more user-friendly, customizable, and scalable
than stock Bugzilla. Check it out at
http://bugzilla.redhat.com and the sources at ftp://people.redhat.com/dkl/.
They've set their Bugzilla up to work with Oracle out of the box.
Note that Redhat Bugzilla is based upon the 2.8 Bugzilla tree;
Bugzilla has made some tremendous advances since the 2.8 release.
Why not download both Bugzillas to check out the differences for
yourself?
</para>
<para>
Dave Lawrence, the original Red Hat Bugzilla maintainer, mentions:
<blockquote>
<para>
Somebody needs to take the ball and run with it. I'm the only
maintainer and am very pressed for time.
</para>
</blockquote>
If you, or someone you know, has the time and expertise to do the integration
work so main-tree Bugzilla 2.12 and higher integrates the Red
Hat Bugzilla Oracle modifications, please donate your
time to supporting the Bugzilla project.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
What are the primary benefits of Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
<emphasis>Dave Lawrence</emphasis>:
<blockquote>
<para>
For the record, we are not using any template type implementation for
the cosmetic changes maded to Bugzilla. It is just alot of html changes
in the code itself. I admit I may have gotten a little carried away with it
but the corporate types asked for a more standardized interface to match up
with other projects relating to Red Hat web sites. A lot of other web based
internal tools I am working on also look like Bugzilla.
</para>
<para>
I do want to land the changes that I have made to Bugzilla but I may
have to back out a good deal and make a different version of Red Hat's
Bugzilla for checking in to CVS. Especially the cosmetic changes because it
seems they may not fit the general public. I will do that as soon as I can.
I also still do my regular QA responsibilities along with Bugzilla so time
is difficult sometimes to come by.
</para>
<para>
There are also a good deal of other changes that were requested by
management for things like support contracts and different permission
groups for making bugs private. Here is a short list of the major
changes that have been made:
</para>
<orderedlist>
<listitem>
<para>
No enum types. All old enum types are now separate smaller tables.
</para>
</listitem>
<listitem>
<para>
No bit wise operations. Not all databases support this so they were
changed to a more generic way of doing this task
</para>
</listitem>
<listitem>
<para>
Bug reports can only be altered by the reporter, assignee, or a
privileged bugzilla user. The rest of the world can see the bug but in
a non-changeable format (unless the bug has been marked private). They
can however add comments, add and remove themselves from the CC list
</para>
</listitem>
<listitem>
<para>
Different group scheme. Each group has an id number related to it.
There is a user_group table which contains userid to groupid mappings
to determine which groups each user belongs to. Additionally there is
a bug_group table that has bugid to groupid mappings to show which
groups can see a particular bug. If there are no entries for a bug in
this table then the bug is public.
</para>
</listitem>
<listitem>
<para>
Product groups. product_table created to only allow certain products to
be visible for certain groups in both bug entry and query. This was
particulary helpful for support contracts.
</para>
</listitem>
<listitem>
<para>
Of course many (too many) changes to Bugzilla code itself to allow use
with Oracle and still allow operation with Mysql if so desired.
Currently if you use Mysql it is set to use Mysql's old permission
scheme to keep breakage to a minimum. Hopefully one day this will
standardize on one style which may of course be something completely
different.
</para>
</listitem>
<listitem>
<para>
Uses Text::Template perl module for rendering of the dynamic HTML pages
such as enter_bug.cgi, query.cgi, bug_form.pl, and for the header and
footer parts of the page. This allows the html to be separate from the
perl code for customizing the look and feel of the page to one's
preference.
</para>
</listitem>
<listitem>
<para>
There are many other smaller changes. There is also a port to Oracle
that I have been working on as time permits but is not completely
finished but somewhat usable. I will merge it into our standard code
base when it becomes production quality. Unfortunately there will have
to be some conditionals in the code to make it work with other than
Oracle due to some differences between Oracle and Mysql.
</para>
</listitem>
</orderedlist>
<para>
Both the Mysql and Oracle versions of our current code base are
available from ftp://people.redhat.com/dkl. If Terry/Tara wants I can submit
patch files for all of the changes I have made and he can determine what is
suitable for addition to the main bugzilla cade base. But for me to commit
changes to the actual CVS I will need to back out alot of things that are
not suitable for the rest of the Bugzilla community. I am open to
suggestions.
</para>
</blockquote>
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
What's the current status of Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
<note>
<para>
This information is somewhat dated; I last updated it
7 June 2000. Please see the "Variants" section of "The Bugzilla Guide"
for more up-to-date information regarding Red Hat Bugzilla.
</para>
</note>
<emphasis>Dave Lawrence</emphasis>:
<blockquote>
<para>
I suppose the current thread warrants an update on the status of
Oracle and bugzilla ;) We have now been running Bugzilla 2.8 on
Oracle for the last two days in our production environment. I
tried to do as much testing as possible with it before going live
which is some of the reason for the long delay. I did not get
enough feedback as I would have liked from internal developers to
help weed out any bugs still left so I said "Fine, i will take it
live and then I will get the feedback I want :)" So it is now
starting to stabilize and it running quite well after working
feverishly the last two days fixing problems as soon as they came
in from the outside world. The current branch in cvs is up2date if
anyone would like to grab it and try it out. The oracle _setup.pl
is broken right now due to some last minute changes but I will
update that soon. Therefore you would probably need to create the
database tables the old fashioned way using the supplied sql
creation scripts located in the ./oracle directory. We have heavy
optimizations in the database it self thanks to the in-house DBA
here at Red Hat so it is running quite fast. The database itself
is located on a dual PII450 with 1GB ram and 14 high voltage
differential raided scsi drives. The tables and indexes are
partitioned in 4 chuncks across the raided drive which is nice
because when ever you need to do a full table scan, it is actually
starting in 4 different locations on 4 different drives
simultaneously. And the indexes of course are on separate drives
from the data so that speeds things up tremendously. When I can
find the time I will document all that we have done to get this
thing going to help others that may need it.
</para>
<para>
As Matt has mentioned it is still using out-dated code and with a
little help I would like to bring everything up to date for
eventual incorporation with the main cvs tree. Due to other
duties I have with the company any help with this wiould be
appreciated. What we are using now is what I call a best first
effort. It definitely can be improved on and may even need
complete rewrites in a lot of areas. A lot of changes may have to
be made in the way Bugzilla does things currently to make this
transition to a more generic database interface. Fortunately when
making the Oracle changes I made sure I didn't do anything that I
would consider Oracle specific and could not be easily done with
other databases. Alot of the sql statements need to be broken up
into smaller utilities that themselves would need to make
decisions on what database they are using but the majority of the
code can be made database neutral.
</para>
</blockquote>
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-loki">
<title>Loki Bugzilla (AKA Fenris)</title>
<qandaentry>
<question>
<para>
What is Loki Bugzilla (Fenris)?
</para>
</question>
<answer>
<para>
Loki Games has a customized version of Bugzilla available at
<ulink url="http://fenris.lokigames.com/">http://fenris.lokigames.com</ulink>. There are some advantages to using Fenris, chief being separation of comments based upon user privacy level, data hiding, forced login for any data retrieval, and some additional fields. Loki has mainted their code, originally a fork from the Bugzilla 2.8 code base, and it is quite a bit different than stock Bugzilla at this point. I recommend you stick with official Bugzilla version &bz-ver; rather than using a fork, but it's up to you.
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-phb">
<title>Pointy-Haired-Boss Questions</title>
<para>
......@@ -596,12 +314,11 @@
</question>
<answer>
<para>
Yes. There are many specific MIME-types that are pre-defined by Bugzilla,
Yes - any sort of attachment is allowed, although administrators can
configure a maximum size.
There are many specific MIME-types that are pre-defined by Bugzilla,
but you may specify any arbitrary MIME-type you need when you
upload the file. Since all attachments are stored in the database,
however, I recommend storing large binary attachments elsewhere
in the web server's file system and providing a hyperlink
as a comment, or in the provided "URL" field in the bug report.
upload the file.
</para>
</answer>
</qandaentry>
......@@ -634,67 +351,12 @@
<question>
<para>
The index.html page doesn't show the footer. It's really annoying to have
to go to the querypage just to check my "my bugs" link. How do I get a footer
on static HTML pages?
to go to the querypage just to check my "my bugs" link.
</para>
</question>
<answer>
<para>
It's possible to get the footer on the static index page using
Server Side Includes (SSI). The trick to doing this is making
sure that your web server is set up to allow SSI and specifically,
the #exec directive. You should also rename <filename>index.html</filename>
to <filename>index.shtml</filename>.
<para>If you upgrade to 2.16, the index page has a footer.
</para>
<para>
After you've done all that, you can add the following line to
<filename>index.shtml</filename>:
<programlisting>
<![CDATA[
<!--#exec cmd="/usr/bin/perl -e &quot;require 'CGI.pl'; PutFooter();&quot;" -->
]]>
</programlisting>
</para>
<para><note>
<para>
This line will be replaced with the actual HTML for the footer
when the page is requested, so you should put this line where you
want the footer to appear.
</para>
</note></para>
<para>
Because this method depends on being able to use a #exec directive,
and most ISP's will not allow that, there is an alternative method.
You could have a small script (such as <filename>api.cgi</filename>)
that basically looks like:
<programlisting>
<![CDATA[
#!/usr/bonsaitools/bin/perl -w
require 'globals.pl';
if ($::FORM{sub} eq 'PutFooter') {
PutFooter();
} else {
die 'api.cgi was incorrectly called';
}
]]>
</programlisting>
and then put this line in <filename>index.shtml</filename>.
<programlisting>
<![CDATA[
<!--#include virtual="api.cgi?sub=PutFooter"-->
]]>
</programlisting>
</para>
<para> <note>
<para>
This still requires being able to use Server Side Includes, if
this simply will not work for you, see <ulink
url="http://bugzilla.mozilla.org/show_bug.cgi?id=80183">bug 80183</ulink>
for a third option.
</para>
</note></para>
</answer>
</qandaentry>
<qandaentry>
......@@ -718,9 +380,6 @@ if ($::FORM{sub} eq 'PutFooter') {
better accomplished through third-party utilities that can
interface with the database directly.
</para>
<para>
Advanced Reporting is a Bugzilla 3.X proposed feature.
</para>
</answer>
</qandaentry>
......@@ -733,8 +392,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Email notification is user-configurable. The bug id and Topic
of the bug report accompany each email notification, along with
Email notification is user-configurable. By default, the bug id and
Summary of the bug report accompany each email notification, along with
a list of the changes made.
</para>
</answer>
......@@ -839,10 +498,10 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Currently, no. Internationalization support for Perl did not
exist in a robust fashion until the recent release of version 5.6.0;
Bugzilla is, and likely will remain (until 3.X) completely
non-localized.
To a certain extent, yes. 2.16's templates mean that you can localise
the user-facing UI (and several projects are doing exactly that.) However,
error messages and the admin interface are currently not localisable.
This should be achieved by 2.18.
</para>
</answer>
</qandaentry>
......@@ -983,13 +642,8 @@ if ($::FORM{sub} eq 'PutFooter') {
<para>
Commercial Bug-tracking software typically costs somewhere upwards
of $20,000 or more for 5-10 floating licenses. Bugzilla consultation
is available from skilled members of the newsgroup.
</para>
<para>
As an example, as of this writing I typically charge
$115 for the first hour, and $89 each hour thereafter
for consulting work. It takes me three to five hours to make Bugzilla
happy on a Development installation of Linux-Mandrake.
is available from skilled members of the newsgroup. Simple questions
are answered there and then.
</para>
</answer>
</qandaentry>
......@@ -1042,9 +696,9 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Check <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink> for details.
Once you download it, untar it, read the Bugzilla Guide.
Check <ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink> for details.
Read the other parts of this Guide for installation instructions.
</para>
</answer>
</qandaentry>
......@@ -1058,7 +712,7 @@ if ($::FORM{sub} eq 'PutFooter') {
<answer>
<para>
Installation on Windows NT has its own section in
"The Bugzilla Guide".
this document.
</para>
</answer>
</qandaentry>
......@@ -1090,8 +744,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Run mysql like this: "mysqld --skip-grant-tables". Please remember <emphasis>this
makes mysql as secure as taping a $100 to the floor of a football stadium
Run MySQL like this: "mysqld --skip-grant-tables". Please remember <emphasis>this
makes MySQL as secure as taping a $100 to the floor of a football stadium
bathroom for safekeeping.</emphasis> Please read the Security section of the
Administration chapter of "The Bugzilla Guide" before proceeding.
</para>
......@@ -1106,8 +760,9 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
The Bugzilla code has not undergone a complete security audit.
It is recommended that you closely examine permissions on your Bugzilla
The Bugzilla code has undergone a reasonably complete security audit,
and user-facing CGIs run under Perl's taint mode. However,
it is recommended that you closely examine permissions on your Bugzilla
installation, and follow the recommended security guidelines found
in The Bugzilla Guide.
</para>
......@@ -1145,8 +800,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
With the email changes to 2.12, the user should be able to set
this in user email preferences.
The user should be able to set
this in user email preferences (uncheck all boxes.)
</para>
</answer>
</qandaentry>
......@@ -1160,7 +815,7 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Edit the param for the mail text. Replace "To:" with "X-Real-To:",
Edit the "changedmail" param. Replace "To:" with "X-Real-To:",
replace "Cc:" with "X-Real-CC:", and add a "To: (myemailaddress)".
</para>
</answer>
......@@ -1224,14 +879,15 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
Email takes FOREVER to reach me from bugzilla -- it's extremely slow.
Email takes FOREVER to reach me from Bugzilla -- it's extremely slow.
What gives?
</para>
</question>
<answer>
<para>
If you are using an alternate Mail Transport Agent (MTA other than
sendmail), make sure the options given in the "processmail" script for all
sendmail), make sure the options given in the "processmail" and other
scripts for all
instances of "sendmail" are correct for your MTA.
</para>
<para>
......@@ -1244,7 +900,7 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
How come email never reaches me from bugzilla changes?
How come email from Bugzilla changes never reaches me?
</para>
</question>
<answer>
......@@ -1274,36 +930,10 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Red Hat Bugzilla, mentioned above, works with Oracle. The current version
Red Hat Bugzilla works with Oracle. The current version
from Mozilla.org does not have this capability. Unfortunately, though
you will sacrifice a lot of the really great features available in
Bugzilla 2.10 and 2.12 if you go with the 2.8-based Redhat version.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
Bugs are missing from queries, but exist in the database (and I can pull
them up by specifying the bug ID). What's wrong?
</para>
</question>
<answer>
<para>
You've almost certainly enabled the "shadow database", but for some
reason it hasn't been updated for all your bugs. This is the database
against which queries are run, so that really complex or slow queries won't
lock up portions of the database for other users. You can turn off the
shadow database in editparams.cgi. If you wish to continue using the shadow
database, then as your "bugs" user run "./syncshadowdb -syncall" from the
command line in the bugzilla installation directory to recreate your shadow
database. After it finishes, be sure to check the params and make sure that
"queryagainstshadowdb" is still turned on. The syncshadowdb program turns it
off if it was on, and is supposed to turn it back on when completed; that
way, if it crashes in the middle of recreating the database, it will stay
off forever until someone turns it back on by hand. Apparently, it doesn't
always do that yet.
Bugzilla 2.14 and 2.16 if you go with the 2.8-based Redhat version.
</para>
</answer>
</qandaentry>
......@@ -1413,42 +1043,6 @@ if ($::FORM{sub} eq 'PutFooter') {
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
Why do I get bizarre errors when trying to submit data, particularly problems
with "groupset"?
</para>
</question>
<answer>
<para>
If you're sure your MySQL parameters are correct, you might want turn
"strictvaluechecks" OFF in editparams.cgi. If you have "usebugsentry" set
"On", you also cannot submit a bug as readable by more than one group with
"strictvaluechecks" ON.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
How come even after I delete bugs, the long descriptions show up?
</para>
</question>
<answer>
<para>
This should only happen with Bugzilla &bz-ver; if you are
using the <quote>shadow database</quote> feature, and your
shadow database is out of sync. Try running
<filename>syncshadowdb</filename>
<option>-syncall</option> to make sure your shadow
database is in synch with your primary database.
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-nt">
......@@ -1518,106 +1112,6 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
Can I have some general instructions on how to make Bugzilla on Win32 work?
</para>
</question>
<answer>
<para>
The following couple entries are deprecated in favor of the Windows installation
instructions available in the "Administration" portion of "The Bugzilla Guide".
However, they are provided here for historical interest and insight.
<literallayout>
1. #!C:/perl/bin/perl had to be added to every perl file.
2. Converted to Net::SMTP to handle mail messages instead of
/usr/bin/sendmail.
3. The crypt function isn't available on Windows NT (at least none that I
am aware), so I made encrypted passwords = plaintext passwords.
4. The system call to diff had to be changed to the Cygwin diff.
5. This was just to get a demo running under NT, it seems to be working
good, and I have inserted almost 100 bugs from another bug tracking
system. Since this work was done just to get an in-house demo, I am NOT
planning on making a patch for submission to Bugzilla. If you would
like a zip file, let me know.
Q: Hmm, couldn't figure it out from the general instructions above. How
about step-by-step?
A: Sure! Here ya go!
1. Install IIS 4.0 from the NT Option Pack #4.
2. Download and install Active Perl.
3. Install the Windows GNU tools from Cygwin. Make sure to add the bin
directory to your system path. (Everyone should have these, whether
they decide to use Bugzilla or not. :-) )
4. Download relevant packages from ActiveState at
http://www.activestate.com/packages/zips/. + DBD-Mysql.zip
5. Extract each zip file with WinZip, and install each ppd file using the
notation: ppm install &lt;module&gt;.ppd
6. Install Mysql. *Note: If you move the default install from c:\mysql,
you must add the appropriate startup parameters to the NT service. (ex.
-b e:\\programs\\mysql)
7. Download any Mysql client. http://www.mysql.com/download_win.html
8. Setup MySql. (These are the commands that I used.)
I. Cleanup default database settings.
C:\mysql\bin\mysql -u root mysql
mysql> DELETE FROM user WHERE Host='localhost' AND User='';
mysql> quit
C:\mysql\bin\mysqladmin reload
II. Set password for root.
C:\mysql\bin\mysql -u root mysql
mysql> UPDATE user SET Password=PASSWORD('new_password')
WHERE user='root';
mysql> FLUSH PRIVILEGES;
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
III. Create bugs user.
C:\mysql\bin\mysql -u root -p
mysql> insert into user (host,user,password)
values('localhost','bugs','');
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
IV. Create the bugs database.
C:\mysql\bin\mysql -u root -p
mysql> create database bugs;
V. Give the bugs user access to the bugs database.
mysql> insert into db
(host,db,user,select_priv,insert_priv,update_priv,delete_priv,create_priv,drop_priv)
values('localhost','bugs','bugs','Y','Y','Y','Y','Y','N')
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
9. Run the table scripts to setup the bugs database.
10. Change CGI.pm to use the following regular expression because of
differing backslashes in NT versus UNIX.
o $0 =~ m:[^\\]*$:;
11. Had to make the crypt password = plain text password in the database.
(Thanks to Andrew Lahser" &lt;andrew_lahser@merck.com&gt;" on this one.) The
files that I changed were:
o globals.pl
o CGI.pl
o alternately, you can try commenting all references to 'crypt'
string and replace them with similar lines but without encrypt()
or crypr() functions insida all files.
12. Replaced sendmail with Windmail. Basically, you have to come up with a
sendmail substitute for NT. Someone said that they used a Perl module
(Net::SMTP), but I was trying to save time and do as little Perl coding
as possible.
13. Added "perl" to the beginning of all Perl system calls that use a perl
script as an argument and renamed processmail to processmail.pl.
14. In processmail.pl, I added binmode(HANDLE) before all read() calls. I'm
not sure about this one, but the read() under NT wasn't counting the
EOLs without the binary read."
</literallayout>
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
I'm having trouble with the perl modules for NT not being able to talk to
to the database.
</para>
......@@ -1673,10 +1167,9 @@ A: Sure! Here ya go!
</question>
<answer>
<para>
We are developing in that direction. You can follow progress on this
at <ulink url="http://bugzilla.mozilla.org/show_bug.cgi?id=16775">
http://bugzilla.mozilla.org/show_bug.cgi?id=16775</ulink>. Some functionality
is available in Bugzilla 2.12, and is available as "quicksearch.html"
The interface was simplified by a UI designer for 2.16. Further
suggestions for improvement are welcome, but we won't sacrifice power for
simplicity.
</para>
</answer>
</qandaentry>
......@@ -1770,9 +1263,9 @@ A: Sure! Here ya go!
enhancement for Bugzilla.
</para>
<para>
You can view bugs marked for 2.16 release
<ulink url="http://bugzilla.mozilla.org/buglist.cgi?product=Bugzilla&amp;target_milestone=Bugzilla+2.16">here</ulink>.
This list includes bugs for the 2.16 release that have already
You can view bugs marked for 2.18 release
<ulink url="http://bugzilla.mozilla.org/buglist.cgi?product=Bugzilla&amp;target_milestone=Bugzilla+2.18">here</ulink>.
This list includes bugs for the 2.18 release that have already
been fixed and checked into CVS. Please consult the
<ulink url="http://www.mozilla.org/projects/bugzilla/">
Bugzilla Project Page</ulink> for details on how to
......@@ -1796,7 +1289,7 @@ A: Sure! Here ya go!
as adding the "---" priority field to your localconfig file in the appropriate area,
re-running checksetup.pl, and then changing the default priority in your browser using
"editparams.cgi". Hmm, now that I think about it, that is kind of a klunky way to handle
it, but for now it's what we have! Although the bug has been closed "resolved wontfix",
it, but for now it's what we have! Although the bug has been closed "RESOLVED WONTFIX",
there may be a better way to handle this...
</para>
</answer>
......@@ -1820,13 +1313,13 @@ A: Sure! Here ya go!
</listitem>
<listitem>
<para>
Upload your patch as a unified DIFF (having used "diff -u" against
Upload your patch as a unified diff (having used "diff -u" against
the <emphasis>current sources</emphasis> checked out of CVS),
or new source file by clicking
"Create a new attachment" link on the bug page you've just created, and
include any descriptions of database changes you may make, into the bug
ID you submitted in step #1. Be sure and click the "Patch" radio
button to indicate the text you are sending is a patch!
ID you submitted in step #1. Be sure and click the "Patch" checkbox
to indicate the text you are sending is a patch!
</para>
</listitem>
<listitem>
......
docs/sgml/gfdl.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="gfdl">
<title>GNU Free Documentation License</title>
<title>GNU Free Documentation License</title>
<!-- - GNU Project - Free Software Foundation (FSF) -->
<!-- LINK REV="made" HREF="mailto:webmasters@gnu.org" -->
<!-- sect1>
<!-- sect1>
<title>GNU Free Documentation License</title -->
<para>Version 1.1, March 2000</para>
<blockquote>
<para>Copyright (C) 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.</para>
<para>Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place,
Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and
distribute verbatim copies of this license document, but changing it is
not allowed.</para>
</blockquote>
<sect1 label="0" id="gfdl-0">
<title>PREAMBLE</title>
<para>The purpose of this License is to make a manual, textbook,
or other written document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or
noncommercially. Secondarily, this License preserves for the
author and publisher a way to get credit for their work, while not
being considered responsible for modifications made by
<para>The purpose of this License is to make a manual, textbook, or other
written document "free" in the sense of freedom: to assure everyone the
effective freedom to copy and redistribute it, with or without modifying
it, either commercially or noncommercially. Secondarily, this License
preserves for the author and publisher a way to get credit for their
work, while not being considered responsible for modifications made by
others.</para>
<para>This License is a kind of "copyleft", which means that
derivative works of the document must themselves be free in the
same sense. It complements the GNU General Public License, which
is a copyleft license designed for free software.</para>
<para>We have designed this License in order to use it for manuals
for free software, because free software needs free documentation:
a free program should come with manuals providing the same
freedoms that the software does. But this License is not limited
to software manuals; it can be used for any textual work,
regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works
whose purpose is instruction or reference.</para>
<para>This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft license
designed for free software.</para>
<para>We have designed this License in order to use it for manuals for
free software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does. But this License is not limited to software manuals; it
can be used for any textual work, regardless of subject matter or whether
it is published as a printed book. We recommend this License principally
for works whose purpose is instruction or reference.</para>
</sect1>
<sect1 label="1" id="gfdl-1">
<title>APPLICABILITY AND DEFINITIONS</title>
<para>This License applies to any manual or other work that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. The "Document",
below, refers to any such manual or work. Any member of the
public is a licensee, and is addressed as "you".</para>
<para>A "Modified Version" of the Document means any work
containing the Document or a portion of it, either copied
verbatim, or with modifications and/or translated into another
language.</para>
<para>A "Secondary Section" is a named appendix or a front-matter
section of the Document that deals exclusively with the
relationship of the publishers or authors of the Document to the
Document's overall subject (or to related matters) and contains
nothing that could fall directly within that overall subject.
(For example, if the Document is in part a textbook of
mathematics, a Secondary Section may not explain any mathematics.)
The relationship could be a matter of historical connection with
the subject or with related matters, or of legal, commercial,
philosophical, ethical or political position regarding
them.</para>
<para>The "Invariant Sections" are certain Secondary Sections
whose titles are designated, as being those of Invariant Sections,
in the notice that says that the Document is released under this
License.</para>
<para>The "Cover Texts" are certain short passages of text that
are listed, as Front-Cover Texts or Back-Cover Texts, in the
notice that says that the Document is released under this
License.</para>
<para>A "Transparent" copy of the Document means a
machine-readable copy, represented in a format whose specification
is available to the general public, whose contents can be viewed
and edited directly and straightforwardly with generic text
editors or (for images composed of pixels) generic paint programs
or (for drawings) some widely available drawing editor, and that
is suitable for input to text formatters or for automatic
translation to a variety of formats suitable for input to text
formatters. A copy made in an otherwise Transparent file format
whose markup has been designed to thwart or discourage subsequent
modification by readers is not Transparent. A copy that is not
"Transparent" is called "Opaque".</para>
<para>Examples of suitable formats for Transparent copies include
plain ASCII without markup, Texinfo input format, LaTeX input
format, SGML or XML using a publicly available DTD, and
standard-conforming simple HTML designed for human modification.
Opaque formats include PostScript, PDF, proprietary formats that
can be read and edited only by proprietary word processors, SGML
or XML for which the DTD and/or processing tools are not generally
available, and the machine-generated HTML produced by some word
<para>This License applies to any manual or other work that contains a
notice placed by the copyright holder saying it can be distributed under
the terms of this License. The "Document", below, refers to any such
manual or work. Any member of the public is a licensee, and is addressed
as "you".</para>
<para>A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.</para>
<para>A "Secondary Section" is a named appendix or a front-matter section
of the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall subject
(or to related matters) and contains nothing that could fall directly
within that overall subject. (For example, if the Document is in part a
textbook of mathematics, a Secondary Section may not explain any
mathematics.) The relationship could be a matter of historical connection
with the subject or with related matters, or of legal, commercial,
philosophical, ethical or political position regarding them.</para>
<para>The "Invariant Sections" are certain Secondary Sections whose
titles are designated, as being those of Invariant Sections, in the
notice that says that the Document is released under this License.</para>
<para>The "Cover Texts" are certain short passages of text that are
listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says
that the Document is released under this License.</para>
<para>A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the general
public, whose contents can be viewed and edited directly and
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or for
automatic translation to a variety of formats suitable for input to text
formatters. A copy made in an otherwise Transparent file format whose
markup has been designed to thwart or discourage subsequent modification
by readers is not Transparent. A copy that is not "Transparent" is called
"Opaque".</para>
<para>Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML or
XML using a publicly available DTD, and standard-conforming simple HTML
designed for human modification. Opaque formats include PostScript, PDF,
proprietary formats that can be read and edited only by proprietary word
processors, SGML or XML for which the DTD and/or processing tools are not
generally available, and the machine-generated HTML produced by some word
processors for output purposes only.</para>
<para>The "Title Page" means, for a printed book, the title page
itself, plus such following pages as are needed to hold, legibly,
the material this License requires to appear in the title page.
For works in formats which do not have any title page as such,
"Title Page" means the text near the most prominent appearance of
the work's title, preceding the beginning of the body of the
text.</para>
<para>The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in formats
which do not have any title page as such, "Title Page" means the text
near the most prominent appearance of the work's title, preceding the
beginning of the body of the text.</para>
</sect1>
<sect1 label="2" id="gfdl-2">
<title>VERBATIM COPYING</title>
<para>You may copy and distribute the Document in any medium,
either commercially or noncommercially, provided that this
License, the copyright notices, and the license notice saying this
License applies to the Document are reproduced in all copies, and
that you add no other conditions whatsoever to those of this
License. You may not use technical measures to obstruct or
control the reading or further copying of the copies you make or
distribute. However, you may accept compensation in exchange for
copies. If you distribute a large enough number of copies you
must also follow the conditions in section 3.</para>
<para>You may also lend copies, under the same conditions stated
above, and you may publicly display copies.</para>
<para>You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies to
the Document are reproduced in all copies, and that you add no other
conditions whatsoever to those of this License. You may not use technical
measures to obstruct or control the reading or further copying of the
copies you make or distribute. However, you may accept compensation in
exchange for copies. If you distribute a large enough number of copies
you must also follow the conditions in section 3.</para>
<para>You may also lend copies, under the same conditions stated above,
and you may publicly display copies.</para>
</sect1>
<sect1 label="3" id="gfdl-3">
<title>COPYING IN QUANTITY</title>
<para>If you publish printed copies of the Document numbering more
than 100, and the Document's license notice requires Cover Texts,
you must enclose the copies in covers that carry, clearly and
legibly, all these Cover Texts: Front-Cover Texts on the front
cover, and Back-Cover Texts on the back cover. Both covers must
also clearly and legibly identify you as the publisher of these
copies. The front cover must present the full title with all
words of the title equally prominent and visible. You may add
other material on the covers in addition. Copying with changes
limited to the covers, as long as they preserve the title of the
Document and satisfy these conditions, can be treated as verbatim
copying in other respects.</para>
<para>If the required texts for either cover are too voluminous to
fit legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto
adjacent pages.</para>
<para>If you publish printed copies of the Document numbering more than
100, and the Document's license notice requires Cover Texts, you must
enclose the copies in covers that carry, clearly and legibly, all these
Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts
on the back cover. Both covers must also clearly and legibly identify you
as the publisher of these copies. The front cover must present the full
title with all words of the title equally prominent and visible. You may
add other material on the covers in addition. Copying with changes
limited to the covers, as long as they preserve the title of the Document
and satisfy these conditions, can be treated as verbatim copying in other
respects.</para>
<para>If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit reasonably)
on the actual cover, and continue the rest onto adjacent pages.</para>
<para>If you publish or distribute Opaque copies of the Document
numbering more than 100, you must either include a
machine-readable Transparent copy along with each Opaque copy, or
state in or with each Opaque copy a publicly-accessible
computer-network location containing a complete Transparent copy
of the Document, free of added material, which the general
network-using public has access to download anonymously at no
charge using public-standard network protocols. If you use the
latter option, you must take reasonably prudent steps, when you
begin distribution of Opaque copies in quantity, to ensure that
this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you
distribute an Opaque copy (directly or through your agents or
retailers) of that edition to the public.</para>
<para>It is requested, but not required, that you contact the
authors of the Document well before redistributing any large
number of copies, to give them a chance to provide you with an
updated version of the Document.</para>
numbering more than 100, you must either include a machine-readable
Transparent copy along with each Opaque copy, or state in or with each
Opaque copy a publicly-accessible computer-network location containing a
complete Transparent copy of the Document, free of added material, which
the general network-using public has access to download anonymously at no
charge using public-standard network protocols. If you use the latter
option, you must take reasonably prudent steps, when you begin
distribution of Opaque copies in quantity, to ensure that this
Transparent copy will remain thus accessible at the stated location until
at least one year after the last time you distribute an Opaque copy
(directly or through your agents or retailers) of that edition to the
public.</para>
<para>It is requested, but not required, that you contact the authors of
the Document well before redistributing any large number of copies, to
give them a chance to provide you with an updated version of the
Document.</para>
</sect1>
<sect1 label="4" id="gfdl-4">
<title>MODIFICATIONS</title>
<para>You may copy and distribute a Modified Version of the
Document under the conditions of sections 2 and 3 above, provided
that you release the Modified Version under precisely this
License, with the Modified Version filling the role of the
Document, thus licensing distribution and modification of the
Modified Version to whoever possesses a copy of it. In addition,
you must do these things in the Modified Version:</para>
<para>You may copy and distribute a Modified Version of the Document
under the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution and
modification of the Modified Version to whoever possesses a copy of it.
In addition, you must do these things in the Modified Version:</para>
<orderedlist numeration="upperalpha">
<listitem><para>Use in the Title Page
(and on the covers, if any) a title distinct from that of the
Document, and from those of previous versions (which should, if
there were any, be listed in the History section of the
Document). You may use the same title as a previous version if
the original publisher of that version gives permission.</para>
<listitem>
<para>Use in the Title Page (and on the covers, if any) a title
distinct from that of the Document, and from those of previous
versions (which should, if there were any, be listed in the History
section of the Document). You may use the same title as a previous
version if the original publisher of that version gives
permission.</para>
</listitem>
<listitem><para>List on the Title Page,
as authors, one or more persons or entities responsible for
authorship of the modifications in the Modified Version,
together with at least five of the principal authors of the
Document (all of its principal authors, if it has less than
five).</para>
<listitem>
<para>List on the Title Page, as authors, one or more persons or
entities responsible for authorship of the modifications in the
Modified Version, together with at least five of the principal
authors of the Document (all of its principal authors, if it has less
than five).</para>
</listitem>
<listitem><para>State on the Title page
the name of the publisher of the Modified Version, as the
publisher.</para>
<listitem>
<para>State on the Title page the name of the publisher of the
Modified Version, as the publisher.</para>
</listitem>
<listitem><para>Preserve all the
copyright notices of the Document.</para>
<listitem>
<para>Preserve all the copyright notices of the Document.</para>
</listitem>
<listitem><para>Add an appropriate
copyright notice for your modifications adjacent to the other
copyright notices.</para>
<listitem>
<para>Add an appropriate copyright notice for your modifications
adjacent to the other copyright notices.</para>
</listitem>
<listitem><para>Include, immediately
after the copyright notices, a license notice giving the public
permission to use the Modified Version under the terms of this
License, in the form shown in the Addendum below.</para>
<listitem>
<para>Include, immediately after the copyright notices, a license
notice giving the public permission to use the Modified Version under
the terms of this License, in the form shown in the Addendum
below.</para>
</listitem>
<listitem><para>Preserve in that license
notice the full lists of Invariant Sections and required Cover
Texts given in the Document's license notice.</para>
<listitem>
<para>Preserve in that license notice the full lists of Invariant
Sections and required Cover Texts given in the Document's license
notice.</para>
</listitem>
<listitem><para>Include an unaltered
copy of this License.</para>
<listitem>
<para>Include an unaltered copy of this License.</para>
</listitem>
<listitem><para>Preserve the section
entitled "History", and its title, and add to it an item stating
at least the title, year, new authors, and publisher of the
Modified Version as given on the Title Page. If there is no
section entitled "History" in the Document, create one stating
the title, year, authors, and publisher of the Document as given
on its Title Page, then add an item describing the Modified
<listitem>
<para>Preserve the section entitled "History", and its title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page. If
there is no section entitled "History" in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.</para>
</listitem>
<listitem><para>Preserve the network
location, if any, given in the Document for public access to a
Transparent copy of the Document, and likewise the network
locations given in the Document for previous versions it was
based on. These may be placed in the "History" section. You
may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.</para>
<listitem>
<para>Preserve the network location, if any, given in the Document
for public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions it
was based on. These may be placed in the "History" section. You may
omit a network location for a work that was published at least four
years before the Document itself, or if the original publisher of the
version it refers to gives permission.</para>
</listitem>
<listitem><para>In any section entitled
"Acknowledgements" or "Dedications", preserve the section's
title, and preserve in the section all the substance and tone of
each of the contributor acknowledgements and/or dedications
given therein.</para>
<listitem>
<para>In any section entitled "Acknowledgements" or "Dedications",
preserve the section's title, and preserve in the section all the
substance and tone of each of the contributor acknowledgements and/or
dedications given therein.</para>
</listitem>
<listitem><para>Preserve all the
Invariant Sections of the Document, unaltered in their text and
in their titles. Section numbers or the equivalent are not
considered part of the section titles.</para>
<listitem>
<para>Preserve all the Invariant Sections of the Document, unaltered
in their text and in their titles. Section numbers or the equivalent
are not considered part of the section titles.</para>
</listitem>
<listitem><para>Delete any section
entitled "Endorsements". Such a section may not be included in
the Modified Version.</para>
<listitem>
<para>Delete any section entitled "Endorsements". Such a section may
not be included in the Modified Version.</para>
</listitem>
<listitem><para>Do not retitle any
existing section as "Endorsements" or to conflict in title with
any Invariant Section.</para>
<listitem>
<para>Do not retitle any existing section as "Endorsements" or to
conflict in title with any Invariant Section.</para>
</listitem>
</orderedlist>
<para>If the Modified Version includes new front-matter sections
or appendices that qualify as Secondary Sections and contain no
material copied from the Document, you may at your option
designate some or all of these sections as invariant. To do this,
add their titles to the list of Invariant Sections in the Modified
Version's license notice. These titles must be distinct from any
other section titles.</para>
<para>You may add a section entitled "Endorsements", provided it
contains nothing but endorsements of your Modified Version by
various parties--for example, statements of peer review or that
the text has been approved by an organization as the authoritative
definition of a standard.</para>
<para>You may add a passage of up to five words as a Front-Cover
Text, and a passage of up to 25 words as a Back-Cover Text, to the
end of the list of Cover Texts in the Modified Version. Only one
passage of Front-Cover Text and one of Back-Cover Text may be
added by (or through arrangements made by) any one entity. If the
Document already includes a cover text for the same cover,
previously added by you or by arrangement made by the same entity
you are acting on behalf of, you may not add another; but you may
replace the old one, on explicit permission from the previous
publisher that added the old one.</para>
<para>The author(s) and publisher(s) of the Document do not by
this License give permission to use their names for publicity for
or to assert or imply endorsement of any Modified Version.</para>
<para>If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all of
these sections as invariant. To do this, add their titles to the list of
Invariant Sections in the Modified Version's license notice. These titles
must be distinct from any other section titles.</para>
<para>You may add a section entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various parties--for
example, statements of peer review or that the text has been approved by
an organization as the authoritative definition of a standard.</para>
<para>You may add a passage of up to five words as a Front-Cover Text,
and a passage of up to 25 words as a Back-Cover Text, to the end of the
list of Cover Texts in the Modified Version. Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or through
arrangements made by) any one entity. If the Document already includes a
cover text for the same cover, previously added by you or by arrangement
made by the same entity you are acting on behalf of, you may not add
another; but you may replace the old one, on explicit permission from the
previous publisher that added the old one.</para>
<para>The author(s) and publisher(s) of the Document do not by this
License give permission to use their names for publicity for or to assert
or imply endorsement of any Modified Version.</para>
</sect1>
<sect1 label="5" id="gfdl-5">
<title>COMBINING DOCUMENTS</title>
<para>You may combine the Document with other documents released
under this License, under the terms defined in section 4 above for
modified versions, provided that you include in the combination
all of the Invariant Sections of all of the original documents,
unmodified, and list them all as Invariant Sections of your
combined work in its license notice.</para>
<para>The combined work need only contain one copy of this
License, and multiple identical Invariant Sections may be replaced
with a single copy. If there are multiple Invariant Sections with
the same name but different contents, make the title of each such
section unique by adding at the end of it, in parentheses, the
name of the original author or publisher of that section if known,
or else a unique number. Make the same adjustment to the section
titles in the list of Invariant Sections in the license notice of
the combined work.</para>
<para>You may combine the Document with other documents released under
this License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and list
them all as Invariant Sections of your combined work in its license
notice.</para>
<para>The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single copy.
If there are multiple Invariant Sections with the same name but different
contents, make the title of each such section unique by adding at the end
of it, in parentheses, the name of the original author or publisher of
that section if known, or else a unique number. Make the same adjustment
to the section titles in the list of Invariant Sections in the license
notice of the combined work.</para>
<para>In the combination, you must combine any sections entitled
"History" in the various original documents, forming one section
entitled "History"; likewise combine any sections entitled
"Acknowledgements", and any sections entitled "Dedications". You
must delete all sections entitled "Endorsements."</para>
"History" in the various original documents, forming one section entitled
"History"; likewise combine any sections entitled "Acknowledgements", and
any sections entitled "Dedications". You must delete all sections
entitled "Endorsements."</para>
</sect1>
<sect1 label="6" id="gfdl-6">
<title>COLLECTIONS OF DOCUMENTS</title>
<para>You may make a collection consisting of the Document and
other documents released under this License, and replace the
individual copies of this License in the various documents with a
single copy that is included in the collection, provided that you
follow the rules of this License for verbatim copying of each of
the documents in all other respects.</para>
<para>You may extract a single document from such a collection,
and distribute it individually under this License, provided you
insert a copy of this License into the extracted document, and
follow this License in all other respects regarding verbatim
copying of that document.</para>
<para>You may make a collection consisting of the Document and other
documents released under this License, and replace the individual copies
of this License in the various documents with a single copy that is
included in the collection, provided that you follow the rules of this
License for verbatim copying of each of the documents in all other
respects.</para>
<para>You may extract a single document from such a collection, and
distribute it individually under this License, provided you insert a copy
of this License into the extracted document, and follow this License in
all other respects regarding verbatim copying of that document.</para>
</sect1>
<sect1 label="7" id="gfdl-7">
<title>AGGREGATION WITH INDEPENDENT WORKS</title>
<para>A compilation of the Document or its derivatives with other
separate and independent documents or works, in or on a volume of
a storage or distribution medium, does not as a whole count as a
Modified Version of the Document, provided no compilation
copyright is claimed for the compilation. Such a compilation is
called an "aggregate", and this License does not apply to the
other self-contained works thus compiled with the Document, on
account of their being thus compiled, if they are not themselves
derivative works of the Document.</para>
<para>If the Cover Text requirement of section 3 is applicable to
these copies of the Document, then if the Document is less than
one quarter of the entire aggregate, the Document's Cover Texts
may be placed on covers that surround only the Document within the
aggregate. Otherwise they must appear on covers around the whole
aggregate.</para>
separate and independent documents or works, in or on a volume of a
storage or distribution medium, does not as a whole count as a Modified
Version of the Document, provided no compilation copyright is claimed for
the compilation. Such a compilation is called an "aggregate", and this
License does not apply to the other self-contained works thus compiled
with the Document, on account of their being thus compiled, if they are
not themselves derivative works of the Document.</para>
<para>If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one quarter of
the entire aggregate, the Document's Cover Texts may be placed on covers
that surround only the Document within the aggregate. Otherwise they must
appear on covers around the whole aggregate.</para>
</sect1>
<sect1 label="8" id="gfdl-8">
<title>TRANSLATION</title>
<para>Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section
4. Replacing Invariant Sections with translations requires
special permission from their copyright holders, but you may
include translations of some or all Invariant Sections in addition
to the original versions of these Invariant Sections. You may
include a translation of this License provided that you also
include the original English version of this License. In case of
a disagreement between the translation and the original English
version of this License, the original English version will
prevail.</para>
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include translations
of some or all Invariant Sections in addition to the original versions of
these Invariant Sections. You may include a translation of this License
provided that you also include the original English version of this
License. In case of a disagreement between the translation and the
original English version of this License, the original English version
will prevail.</para>
</sect1>
<sect1 label="9" id="gfdl-9">
<title>TERMINATION</title>
<para>You may not copy, modify, sublicense, or distribute the
Document except as expressly provided for under this License. Any
other attempt to copy, modify, sublicense or distribute the
Document is void, and will automatically terminate your rights
under this License. However, parties who have received copies, or
rights, from you under this License will not have their licenses
terminated so long as such parties remain in full
<para>You may not copy, modify, sublicense, or distribute the Document
except as expressly provided for under this License. Any other attempt to
copy, modify, sublicense or distribute the Document is void, and will
automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full
compliance.</para>
</sect1>
<sect1 label="10" id="gfdl-10">
<title>FUTURE REVISIONS OF THIS LICENSE</title>
<para>The Free Software Foundation may publish new, revised
versions of the GNU Free Documentation License from time to time.
Such new versions will be similar in spirit to the present
version, but may differ in detail to address new problems or
concerns. See <ulink
url="http://www.gnu.org/copyleft/">http://www.gnu.org/copyleft/</ulink>.</para>
<para>Each version of the License is given a distinguishing
version number. If the Document specifies that a particular
numbered version of this License "or any later version" applies to
it, you have the option of following the terms and conditions
either of that specified version or of any later version that has
been published (not as a draft) by the Free Software Foundation.
If the Document does not specify a version number of this License,
you may choose any version ever published (not as a draft) by the
Free Software Foundation.</para>
<para>The Free Software Foundation may publish new, revised versions of
the GNU Free Documentation License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in
detail to address new problems or concerns. See
<ulink url="http://www.gnu.org/copyleft/">
http://www.gnu.org/copyleft/</ulink>
.</para>
<para>Each version of the License is given a distinguishing version
number. If the Document specifies that a particular numbered version of
this License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or of
any later version that has been published (not as a draft) by the Free
Software Foundation. If the Document does not specify a version number of
this License, you may choose any version ever published (not as a draft)
by the Free Software Foundation.</para>
</sect1>
<sect1 label="" id="gfdl-howto">
<title>How to use this License for your documents</title>
<para>To use this License in a document you have written, include
a copy of the License in the document and put the following
copyright and license notices just after the title page:</para>
<blockquote><para>
Copyright (c) YEAR YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation;
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
A copy of the license is included in the section entitled "GNU
Free Documentation License".
</para></blockquote>
<para>To use this License in a document you have written, include a copy
of the License in the document and put the following copyright and
license notices just after the title page:</para>
<blockquote>
<para>Copyright (c) YEAR YOUR NAME. Permission is granted to copy,
distribute and/or modify this document under the terms of the GNU Free
Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Sections being LIST
THEIR TITLES, with the Front-Cover Texts being LIST, and with the
Back-Cover Texts being LIST. A copy of the license is included in the
section entitled "GNU Free Documentation License".</para>
</blockquote>
<para>If you have no Invariant Sections, write "with no Invariant
Sections" instead of saying which ones are invariant. If you have
no Front-Cover Texts, write "no Front-Cover Texts" instead of
"Front-Cover Texts being LIST"; likewise for Back-Cover
Texts.</para>
<para>If your document contains nontrivial examples of program
code, we recommend releasing these examples in parallel under your
choice of free software license, such as the GNU General Public
License, to permit their use in free software.</para>
Sections" instead of saying which ones are invariant. If you have no
Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover
Texts being LIST"; likewise for Back-Cover Texts.</para>
<para>If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of free
software license, such as the GNU General Public License, to permit their
use in free software.</para>
</sect1>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -472,3 +445,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/glossary.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook V4.1//EN" > -->
<glossary id="glossary">
<glossary id="glossary">
<glossdiv>
<title>0-9, high ascii</title>
<glossentry>
<glossterm>.htaccess</glossterm>
<glossdef>
<para>
Apache web server, and other NCSA-compliant web servers,
observe the convention of using files in directories
called <filename>.htaccess</filename> files. These
restrict parameters of the web server. In Bugzilla, they
are used to restrict access to certain files which would
otherwise compromise your installation. For instance, the
<filename>localconfig</filename> file contains the
password to your database. If this information were
generally available, and remote access to your database
turned on, you risk corruption of your database by
computer criminals or the curious.
</para>
<para>Apache web server, and other NCSA-compliant web servers,
observe the convention of using files in directories called
<filename>.htaccess</filename>
to restrict access to certain files. In Bugzilla, they are used
to keep secret files which would otherwise
compromise your installation - e.g. the
<filename>localconfig</filename>
file contains the password to your database. If this information were
generally available, and remote access to your database turned on,
you risk corruption of your database by computer criminals or the
curious.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-a">
<title>A</title>
<glossentry>
<glossterm>Apache</glossterm>
<glossdef>
<para>In this context, Apache is the web server most
commonly used for serving up
<glossterm>Bugzilla</glossterm> pages. Contrary to
popular belief, the apache web server has nothing to do
with the ancient and noble Native American tribe, but
instead derived its name from the fact that it was
<quote>a patchy</quote> version of the original
<acronym>NCSA</acronym> world-wide-web server.</para>
<para>In this context, Apache is the web server most commonly used
for serving up
<glossterm>Bugzilla</glossterm>
pages. Contrary to popular belief, the apache web server has nothing
to do with the ancient and noble Native American tribe, but instead
derived its name from the fact that it was
<quote>a patchy</quote>
version of the original
<acronym>NCSA</acronym>
world-wide-web server.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-b">
<title>B</title>
<glossentry>
<glossterm>Bug</glossterm>
<glossdef>
<para>
A <quote>Bug</quote> in Bugzilla refers to an issue
entered into the database which has an associated number,
assignments, comments, etc. Some also refer to a
<quote>tickets</quote> or <quote>issues</quote>; in the
context of Bugzilla, they are synonymous.
</para>
<para>A
<quote>Bug</quote>
in Bugzilla refers to an issue entered into the database which has an
associated number, assignments, comments, etc. Some also refer to a
<quote>tickets</quote>
or
<quote>issues</quote>;
in the context of Bugzilla, they are synonymous.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bug Number</glossterm>
<glossdef>
<para>
Each Bugzilla Bug is assigned a number that uniquely
identifies that Bug. The Bug associated with a Bug Number
can be pulled up via a query, or easily from the very
front page by typing the number in the "Find" box.
</para>
<para>Each Bugzilla Bug is assigned a number that uniquely identifies
that Bug. The Bug associated with a Bug Number can be pulled up via a
query, or easily from the very front page by typing the number in the
"Find" box.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bug Life Cycle</glossterm>
<glossdef>
<para>A Bug has stages through which it must pass before
becoming a <quote>closed bug</quote>, including
acceptance, resolution, and verification. The <quote>Bug
Life Cycle</quote> is moderately flexible according to
the needs of the organization using it, though.</para>
<para>A Bug has stages through which it must pass before becoming a
<quote>closed bug</quote>,
including acceptance, resolution, and verification. The
<quote>Bug Life Cycle</quote>
is moderately flexible according to the needs of the organization
using it, though.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bugzilla</glossterm>
<glossdef>
<para>
Bugzilla is the industry-standard bug tracking system. It
is quite popular among Open Source enthusiasts.
</para>
<para>Bugzilla is the industry-standard bug tracking system. It is
quite popular among Open Source enthusiasts.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-c">
<title></title>
<title>
</title>
<glossentry id="gloss-component">
<glossterm>Component</glossterm>
<glossdef>
<para>
A Component is a subsection of a Product. It should be a
narrow category, tailored to your organization. All
Products must contain at least one Component (and, as a
matter of fact, creating a Product with no Components will
create an error in Bugzilla).
</para>
<para>A Component is a subsection of a Product. It should be a narrow
category, tailored to your organization. All Products must contain at
least one Component (and, as a matter of fact, creating a Product
with no Components will create an error in Bugzilla).</para>
</glossdef>
</glossentry>
<glossentry id="gloss-cpan">
<glossterm><acronym>CPAN</acronym></glossterm>
<glossterm>
<acronym>CPAN</acronym>
</glossterm>
<glossdef>
<para><acronym>CPAN</acronym> stands for the
<quote>Comprehensive Perl Archive Network</quote>. CPAN
maintains a large number of extremely useful
<glossterm>Perl</glossterm> modules. By themselves, Perl
modules generally do nothing, but when used as part of a
larger program, they provide much-needed algorithms and
functionality.</para>
<para>
<acronym>CPAN</acronym>
stands for the
<quote>Comprehensive Perl Archive Network</quote>
. CPAN maintains a large number of extremely useful
<glossterm>Perl</glossterm>
modules. By themselves, Perl modules generally do nothing, but when
used as part of a larger program, they provide much-needed algorithms
and functionality.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-d">
<title>D</title>
<glossentry>
<glossterm>daemon</glossterm>
<glossdef>
<para>A daemon is a computer program which runs in the
background. In general, most daemons are started at boot
time via System V init scripts, or through RC scripts on
BSD-based systems. <glossterm>mysqld</glossterm>, the
MySQL server, and <glossterm>apache</glossterm>, a web
server, are generally run as daemons.</para>
<para>A daemon is a computer program which runs in the background. In
general, most daemons are started at boot time via System V init
scripts, or through RC scripts on BSD-based systems.
<glossterm>mysqld</glossterm>,
the MySQL server, and
<glossterm>apache</glossterm>,
a web server, are generally run as daemons.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-g">
<title></title>
<title>
</title>
<glossentry>
<glossterm>Groups</glossterm>
<glossdef>
<para>The word <quote>Groups</quote> has a very special
meaning to Bugzilla. Bugzilla's main security mechanism
comes by lumping users into groups, and assigning those
<para>The word
<quote>Groups</quote>
has a very special meaning to Bugzilla. Bugzilla's main security
mechanism comes by lumping users into groups, and assigning those
groups certain privileges to
<glossterm>Products</glossterm> and
<glossterm>Components</glossterm> in the
<glossterm>Bugzilla</glossterm> database.</para>
<glossterm>Products</glossterm>
and
<glossterm>Components</glossterm>
in the
<glossterm>Bugzilla</glossterm>
database.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-i">
<title>I</title>
<glossentry id="gloss-infiniteloop">
<glossterm>Infinite Loop</glossterm>
<glossdef>
<para>A loop of information that never ends; see recursion.</para>
</glossdef>
......@@ -160,144 +198,168 @@
<glossdiv id="gloss-m">
<title>M</title>
<glossentry>
<glossterm>mysqld</glossterm>
<glossdef>
<para>mysqld is the name of the
<glossterm>daemon</glossterm> for the MySQL database. In
general, it is invoked automatically through the use of
the System V init scripts on GNU/Linux and AT&amp;T System
V-based systems, such as Solaris and HP/UX, or through the
RC scripts on BSD-based systems.</para>
<glossterm>daemon</glossterm>
for the MySQL database. In general, it is invoked automatically
through the use of the System V init scripts on GNU/Linux and
AT&amp;T System V-based systems, such as Solaris and HP/UX, or
through the RC scripts on BSD-based systems.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-p">
<title>P</title>
<glossentry>
<glossterm id="gloss-product">Product</glossterm>
<glossdef>
<para>A Product is a broad category of types of bugs. In
general, there are several Components to a Product. A
Product also defines a default Group (used for Bug
Security) for all bugs entered into components beneath
it.</para>
<example>
<title>A Sample Product</title>
<para>A company sells a software product called
<quote>X</quote>. They also maintain some older
software called <quote>Y</quote>, and have a secret
project <quote>Z</quote>. An effective use of Products
might be to create Products <quote>X</quote>,
<quote>Y</quote>, <quote>Z</quote>, each with Components
of User Interface, Database, and Business Logic. They
might also change group permissions so that only those
people who are members of Group <quote>Z</quote> can see
components and bugs under Product
<quote>Z</quote>.</para>
</example>
<para>A Product is a broad category of types of bugs. In general,
there are several Components to a Product. A Product may also define a
group (used for security) for all bugs entered into
components beneath it.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Perl</glossterm>
<glossdef>
<para>First written by Larry Wall, Perl is a remarkable
program language. It has the benefits of the flexibility
of an interpreted scripting language (such as shell
script), combined with the speed and power of a compiled
language, such as C. <glossterm>Bugzilla</glossterm> is
maintained in Perl.</para>
<para>First written by Larry Wall, Perl is a remarkable program
language. It has the benefits of the flexibility of an interpreted
scripting language (such as shell script), combined with the speed
and power of a compiled language, such as C.
<glossterm>Bugzilla</glossterm>
is maintained in Perl.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-q">
<title>Q</title>
<glossentry>
<glossterm>QA</glossterm>
<glossdef>
<para><quote>QA</quote>, <quote>Q/A</quote>, and
<quote>Q.A.</quote> are short for <quote>Quality
Assurance</quote>. In most large software development
organizations, there is a team devoted to ensuring the
product meets minimum standards before shipping. This
team will also generally want to track the progress of
<para>
<quote>QA</quote>,
<quote>Q/A</quote>, and
<quote>Q.A.</quote>
are short for
<quote>Quality Assurance</quote>.
In most large software development organizations, there is a team
devoted to ensuring the product meets minimum standards before
shipping. This team will also generally want to track the progress of
bugs over their life cycle, thus the need for the
<quote>QA Contact</quote> field in a Bug.</para>
<quote>QA Contact</quote>
field in a Bug.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-r">
<title>R</title>
<glossentry id="gloss-recursion" xreflabel="Recursion">
<glossterm>Recursion</glossterm>
<glossdef>
<para>The property of a function looking back at itself for
something. <quote>GNU</quote>, for instance, stands for
<quote>GNU's Not UNIX</quote>, thus recursing upon itself
for definition. For further clarity, see Infinite
Loop.</para>
something.
<quote>GNU</quote>, for instance, stands for
<quote>GNU's Not UNIX</quote>,
thus recursing upon itself for definition. For further clarity, see
Infinite Loop.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-s">
<title>S</title>
<glossentry>
<glossterm><acronym>SGML</acronym></glossterm>
<glossterm>
<acronym>SGML</acronym>
</glossterm>
<glossdef>
<para><acronym>SGML</acronym> stands for <quote>Standard
Generalized Markup Language</quote>. Created in the
1980's to provide an extensible means to maintain
<para>
<acronym>SGML</acronym>
stands for
<quote>Standard Generalized Markup Language</quote>.
Created in the 1980's to provide an extensible means to maintain
documentation based upon content instead of presentation,
<acronym>SGML</acronym> has withstood the test of time as
a robust, powerful language.
<glossterm><acronym>XML</acronym></glossterm> is the
<quote>baby brother</quote> of SGML; any valid
<acronym>XML</acronym> document it, by definition, a valid
<acronym>SGML</acronym> document. The document you are
reading is written and maintained in
<acronym>SGML</acronym>, and is also valid
<acronym>XML</acronym> if you modify the Document Type
Definition.</para>
<acronym>SGML</acronym>
has withstood the test of time as a robust, powerful language.
<glossterm>
<acronym>XML</acronym>
</glossterm>
is the
<quote>baby brother</quote>
of SGML; any valid
<acronym>XML</acronym>
document it, by definition, a valid
<acronym>SGML</acronym>
document. The document you are reading is written and maintained in
<acronym>SGML</acronym>,
and is also valid
<acronym>XML</acronym>
if you modify the Document Type Definition.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-t">
<title>T</title>
<glossentry id="gloss-target-milestone" xreflabel="Target Milestone">
<glossterm>Target Milestone</glossterm>
<glossdef>
<para>
Target Milestones are Product goals. They are
configurable on a per-Product basis. Most software
development houses have a concept of
<quote>milestones</quote> where the people funding a
project expect certain functionality on certain dates.
Bugzilla facilitates meeting these milestones by giving
you the ability to declare by which milestone a bug will be
fixed, or an enhancement will be implemented.
</para>
<para>Target Milestones are Product goals. They are configurable on a
per-Product basis. Most software development houses have a concept of
<quote>milestones</quote>
where the people funding a project expect certain functionality on
certain dates. Bugzilla facilitates meeting these milestones by
giving you the ability to declare by which milestone a bug will be
fixed, or an enhancement will be implemented.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-z">
<title>Z</title>
<glossentry id="zarro-boogs-found" xreflabel="Zarro Boogs Found">
<glossterm>Zarro Boogs Found</glossterm>
<glossdef>
<para>This is the cryptic response sent by Bugzilla when a
query returned no results. It is just a goofy way of
saying "Zero Bugs Found".</para>
<para>This is the cryptic response sent by Bugzilla when a query
returned no results. It is just a goofy way of saying "Zero Bugs
Found".</para>
</glossdef>
</glossentry>
</glossdiv>
</glossary>
</glossary>
<!-- Keep this comment at the end of the file
Local variables:
......@@ -319,3 +381,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/index.sgml
View file @ 74bcd6f1
......@@ -18,3 +18,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/integration.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN" > -->
<!-- Keep these tools listings in alphabetical order please. -MPB -->
<chapter id="integration">
<title>Integrating Bugzilla with Third-Party Tools</title>
<section id="bonsai" xreflabel="Bonsai, the Mozilla automated CVS management system">
<section id="bonsai"
xreflabel="Bonsai, the Mozilla automated CVS management system">
<title>Bonsai</title>
<para>Bonsai is a web-based tool for managing <xref
linkend="cvs" />
. Using Bonsai, administrators can control open/closed status
of trees, query a fast relational database back-end for change,
branch, and comment information, and view changes made since the
last time the tree was closed. These kinds of changes cause the
engineer responsible to be <quote>on the hook</quote> (include
cool URL link here for Hook policies at mozilla.org). Bonsai
also includes gateways to <xref
linkend="tinderbox" /> and Bugzilla </para>
<para>Bonsai is a web-based tool for managing
<xref linkend="cvs" />
. Using Bonsai, administrators can control open/closed status of trees,
query a fast relational database back-end for change, branch, and comment
information, and view changes made since the last time the tree was
closed. These kinds of changes cause the engineer responsible to be
<quote>on the hook</quote>
(include cool URL link here for Hook policies at mozilla.org). Bonsai
also includes gateways to
<xref linkend="tinderbox" />
and Bugzilla</para>
</section>
<section id="cvs" xreflabel="CVS, the Concurrent Versioning System">
<title>CVS</title>
<para>CVS integration is best accomplished, at this point, using
the Bugzilla Email Gateway. There have been some files
submitted to allow greater CVS integration, but we need to make
certain that Bugzilla is not tied into one particular software
management package.</para>
<para>
Follow the instructions in the FAQ for enabling Bugzilla e-mail
integration. Ensure that your check-in script sends an email to
your Bugzilla e-mail gateway with the subject of <quote>[Bug
XXXX]</quote>, and you can have CVS check-in comments append
to your Bugzilla bug. If you have your check-in script include
an @resolution field, you can even change the Bugzilla bug
state.
</para>
<para>
There is also a project, based upon somewhat dated Bugzilla
code, to integrate CVS and Bugzilla through CVS' ability to
email. Check it out at:
<para>CVS integration is best accomplished, at this point, using the
Bugzilla Email Gateway. There have been some files submitted to allow
greater CVS integration, but we need to make certain that Bugzilla is not
tied into one particular software management package.</para>
<para>Follow the instructions in the FAQ for enabling Bugzilla e-mail
integration. Ensure that your check-in script sends an email to your
Bugzilla e-mail gateway with the subject of
<quote>[Bug XXXX]</quote>
, and you can have CVS check-in comments append to your Bugzilla bug. If
you have your check-in script include an @resolution field, you can even
change the Bugzilla bug state.</para>
<para>There is also a project, based upon somewhat dated Bugzilla code,
to integrate CVS and Bugzilla through CVS' ability to email. Check it out
at:
<ulink url="http://homepages.kcbbs.gen.nz/~tonyg/">
http://homepages.kcbbs.gen.nz/~tonyg/</ulink>, under the
<quote>cvszilla</quote> link.
</para>
http://homepages.kcbbs.gen.nz/~tonyg/</ulink>
, under the
<quote>cvszilla</quote>
link.</para>
</section>
<section id="scm" xreflabel="Perforce SCM (Fast Software Configuration Management System, a powerful commercial alternative to CVS">
<section id="scm"
xreflabel="Perforce SCM (Fast Software Configuration Management System, a powerful commercial alternative to CVS">
<title>Perforce SCM</title>
<para>
You can find the project page for Bugzilla and Teamtrack
Perforce integration (p4dti) at: <ulink
url="http://www.ravenbrook.com/project/p4dti/"> http://www.ravenbrook.com/project/p4dti</ulink> . <quote>p4dti</quote> is now an officially supported product from Perforce, and you can find the "Perforce Public Depot" p4dti page at <ulink url="http://public.perforce.com/public/perforce/p4dti/index.html"> http://public.perforce.com/public/perforce/p4dti/index.html</ulink>.
</para>
<para>
Integration of Perforce with Bugzilla, once patches are applied,
is seamless. Perforce replication information will appear below
the comments of each bug. Be certain you have a matching set of
patches for the Bugzilla version you are installing. p4dti is
designed to support multiple defect trackers, and maintains its
own documentation for it. Please consult the pages linked above
for further information.
</para>
<para>You can find the project page for Bugzilla and Teamtrack Perforce
integration (p4dti) at:
<ulink url="http://www.ravenbrook.com/project/p4dti/">
http://www.ravenbrook.com/project/p4dti</ulink>
.
<quote>p4dti</quote>
is now an officially supported product from Perforce, and you can find
the "Perforce Public Depot" p4dti page at
<ulink url="http://public.perforce.com/public/perforce/p4dti/index.html">
http://public.perforce.com/public/perforce/p4dti/index.html</ulink>
.</para>
<para>Integration of Perforce with Bugzilla, once patches are applied, is
seamless. Perforce replication information will appear below the comments
of each bug. Be certain you have a matching set of patches for the
Bugzilla version you are installing. p4dti is designed to support
multiple defect trackers, and maintains its own documentation for it.
Please consult the pages linked above for further information.</para>
</section>
<section id="tinderbox" xreflabel="Tinderbox, the Mozilla automated build management system">
<section id="tinderbox"
xreflabel="Tinderbox, the Mozilla automated build management system">
<title>Tinderbox/Tinderbox2</title>
<para>We need Tinderbox integration information.</para>
</section>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -93,3 +108,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/patches.sgml
View file @ 74bcd6f1
<!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
<appendix id="patches" xreflabel="Useful Patches and Utilities for Bugzilla">
<title>Useful Patches and Utilities for Bugzilla</title>
<para>Are you looking for a way to put your Bugzilla into overdrive? Catch some of the niftiest tricks here in this section.</para>
<para>Are you looking for a way to put your Bugzilla into overdrive? Catch
some of the niftiest tricks here in this section.</para>
<section id="rewrite" xreflabel="Apache mod_rewrite magic">
<title>Apache <filename>mod_rewrite</filename> magic</title>
<para>Apache's <filename>mod_rewrite</filename> module lets you do some truly amazing things with URL rewriting. Here are a couple of examples of what you can do.</para>
<title>Apache
<filename>mod_rewrite</filename>
magic</title>
<para>Apache's
<filename>mod_rewrite</filename>
module lets you do some truly amazing things with URL rewriting. Here are
a couple of examples of what you can do.</para>
<orderedlist>
<listitem>
<para>
Make it so if someone types
<computeroutput>http://www.foo.com/12345</computeroutput>,
Bugzilla spits back
http://www.foo.com/show_bug.cgi?id=12345. Try setting up
your VirtualHost section for Bugzilla with a rule like
<para>Make it so if someone types
<computeroutput>http://www.foo.com/12345</computeroutput>
, Bugzilla spits back http://www.foo.com/show_bug.cgi?id=12345. Try
setting up your VirtualHost section for Bugzilla with a rule like
this:</para>
<programlisting>
<![CDATA[
<VirtualHost 12.34.56.78>
......@@ -25,96 +34,118 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
</VirtualHost>
]]>
</programlisting>
</listitem>
<listitem>
<para>There are many, many more things you can do with
mod_rewrite. As time goes on, I will include many more in
the Guide. For now, though, please refer to the mod_rewrite
documentation at <ulink
url="http://www.apache.org">http://www.apache.org</ulink></para>
<para>There are many, many more things you can do with mod_rewrite.
As time goes on, I will include many more in the Guide. For now,
though, please refer to the mod_rewrite documentation at
<ulink url="http://www.apache.org">http://www.apache.org</ulink>
</para>
</listitem>
</orderedlist>
</section>
<section id="setperl" xreflabel="The setperl.csh Utility">
<section id="setperl" xreflabel="The setperl.csh Utility">
<title>The setperl.csh Utility</title>
<para> You can use the "setperl.csh" utility to quickly and
easily change the path to perl on all your Bugzilla files. This
is a C-shell script; if you do not have "csh" or "tcsh" in the
search path on your system, it will not work!
</para>
<para>You can use the "setperl.csh" utility to quickly and easily change
the path to perl on all your Bugzilla files. This is a C-shell script; if
you do not have "csh" or "tcsh" in the search path on your system, it
will not work!</para>
<procedure>
<step>
<para>
Download the "setperl.csh" utility to your Bugzilla
directory and make it executable.
</para>
<para>Download the "setperl.csh" utility to your Bugzilla directory
and make it executable.</para>
<substeps>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>cd /your/path/to/bugzilla</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>wget -O
setperl.csh
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=10795'</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>wget -O setperl.csh
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=10795'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>chmod
u+x setperl.csh</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+x setperl.csh</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>
Prepare (and fix) Bugzilla file permissions.
</para>
<para>Prepare (and fix) Bugzilla file permissions.</para>
<substeps>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+w *</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>chmod
u+x duplicates.cgi</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+x duplicates.cgi</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod a-x bug_status.html</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>Run the script:</para>
<para>
Run the script:
</para>
<para>
<computeroutput> <prompt>bash#</prompt>
<computeroutput>
<prompt>bash#</prompt>
<command>./setperl.csh /your/path/to/perl</command>
</computeroutput>
<example>
<example>
<title>Using Setperl to set your perl path</title>
<para>
<computeroutput> <prompt>bash#</prompt>
<computeroutput>
<prompt>bash#</prompt>
<command>./setperl.csh /usr/bin/perl</command>
</computeroutput>
</para>
......@@ -126,78 +157,85 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
<section id="cmdline">
<title>Command-line Bugzilla Queries</title>
<para>
Users can query Bugzilla from the command line using this suite
of utilities.
</para>
<para>
The query.conf file contains the mapping from options to field
names and comparison types. Quoted option names are "grepped"
for, so it should be easy to edit this file. Comments (#) have
no effect; you must make sure these lines do not contain any
quoted "option"
</para>
<para>
buglist is a shell script which submits a Bugzilla query and
writes the resulting HTML page to stdout. It supports both
short options, (such as "-Afoo" or "-Rbar") and long options
(such as "--assignedto=foo" or "--reporter=bar"). If the first
character of an option is not "-", it is treated as if it were
prefixed with "--default=".
</para>
<para>
The columlist is taken from the COLUMNLIST environment variable.
This is equivalent to the "Change Columns" option when you list
bugs in buglist.cgi. If you have already used Bugzilla, use
<command>grep COLUMLIST ~/.netscape/cookies</command> to see
your current COLUMNLIST setting.
</para>
<para>
bugs is a simple shell script which calls buglist and extracts
the bug numbers from the output. Adding the prefix
"http://bugzilla.mozilla.org/buglist.cgi?bug_id=" turns the bug
list into a working link if any bugs are found. Counting bugs is
easy. Pipe the results through <command>sed -e 's/,/ /g' | wc |
awk '{printf $2 "\n"}'</command>
<para>Users can query Bugzilla from the command line using this suite of
utilities.</para>
<para>The query.conf file contains the mapping from options to field
names and comparison types. Quoted option names are "grepped" for, so it
should be easy to edit this file. Comments (#) have no effect; you must
make sure these lines do not contain any quoted "option"</para>
<para>buglist is a shell script which submits a Bugzilla query and writes
the resulting HTML page to stdout. It supports both short options, (such
as "-Afoo" or "-Rbar") and long options (such as "--assignedto=foo" or
"--reporter=bar"). If the first character of an option is not "-", it is
treated as if it were prefixed with "--default=".</para>
<para>The columlist is taken from the COLUMNLIST environment variable.
This is equivalent to the "Change Columns" option when you list bugs in
buglist.cgi. If you have already used Bugzilla, use
<command>grep COLUMLIST ~/.netscape/cookies</command>
to see your current COLUMNLIST setting.</para>
<para>bugs is a simple shell script which calls buglist and extracts the
bug numbers from the output. Adding the prefix
"http://bugzilla.mozilla.org/buglist.cgi?bug_id=" turns the bug list into
a working link if any bugs are found. Counting bugs is easy. Pipe the
results through
<command>sed -e 's/,/ /g' | wc | awk '{printf $2 "\n"}'</command>
</para>
<para>
Akkana says she has good results piping buglist output through
<para>Akkana says she has good results piping buglist output through
<command>w3m -T text/html -dump</command>
</para>
<procedure>
<step>
<para>
Download three files:
</para>
<para>Download three files:</para>
<substeps>
<step>
<para>
<computeroutput> <prompt>bash$</prompt> <command>wget -O
query.conf
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26157'</command> </computeroutput>
<computeroutput>
<prompt>bash$</prompt>
<command>wget -O query.conf
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26157'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash$</prompt> <command>wget -O
buglist
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26944'</command> </computeroutput>
<computeroutput>
<prompt>bash$</prompt>
<command>wget -O buglist
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26944'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>wget -O
bugs
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26215'</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>wget -O bugs
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26215'</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>
Make your utilities executable:
<para>Make your utilities executable:
<computeroutput>
<prompt>bash$</prompt>
<command>chmod u+x buglist bugs</command>
</computeroutput>
</para>
......@@ -207,275 +245,44 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
<section id="quicksearch">
<title>The Quicksearch Utility</title>
<para>
Quicksearch is a new, experimental feature of the 2.12 release.
It consist of two Javascript files, "quicksearch.js" and
"localconfig.js", and two documentation files,
"quicksearch.html" and "quicksearchhack.html"
</para>
<para>
The index.html page has been updated to include the QuickSearch
text box.
</para>
<para>
To take full advantage of the query power, the Bugzilla
maintainer must edit "localconfig.js" according to the value
sets used in the local installation.
</para>
<para>
Currently, keywords must be hard-coded in localconfig.js. If
they are not, keywords are not automatically recognized. This
means, if localconfig.js is left unconfigured, that searching
for a bug with the "foo" keyword will only find bugs with "foo"
in the summary, status whiteboard, product or component name,
but not those with the keyword "foo".
</para>
<para>
Workarounds for Bugzilla users:
<simplelist>
<member>search for '!foo' (this will find only bugs with the
keyword "foo"</member>
<member>search 'foo,!foo' (equivalent to 'foo OR
keyword:foo')</member>
</simplelist>
</para>
<para>
When this tool is ported from client-side JavaScript to
server-side Perl, the requirement for hard-coding keywords can
be fixed. <ulink
url="http://bugzilla.mozilla.org/show_bug.cgi?id=70907">This bug</ulink> has details.
</para>
</section>
<section id="bzhacking">
<title>Hacking Bugzilla</title>
<para>
The following is a guide for reviewers when checking code into Bugzilla's
CVS repostory at mozilla.org. If you wish to submit patches to Bugzilla,
you should follow the rules and style conventions below. Any code that
does not adhere to these basic rules will not be added to Bugzilla's
codebase.
</para>
<section>
<title>Things that have caused problems and should be avoided</title>
<orderedlist>
<listitem>
<para>
Usage of variables in Regular Expressions
</para>
<para>
It is very important that you don't use a variable in a regular
expression unless that variable is supposed to contain an expression.
This especially applies when using grep. You should use:
</para>
<para>
<programlisting>
grep ($_ eq $value, @array);
</programlisting>
</para>
<para>
-- NOT THIS --
</para>
<para>
<programlisting>
grep (/$value/, @array);
</programlisting>
</para>
<note>
<para>
If you need to use a non-expression variable inside of an expression, be
sure to quote it properly (using <function>\Q..\E</function>).
</para>
</note>
</listitem>
</orderedlist>
</section>
<section>
<title>Coding Style for Bugzilla</title>
<para>
While it's true that not all of the code currently in Bugzilla adheres to
this (or any) styleguide, it is something that is being worked toward. Therefore,
we ask that all new code (submitted patches and new files) follow this guide
as closely as possible (if you're only changing 1 or 2 lines, you don't have
to reformat the entire file :).
</para>
<para>
The Bugzilla development team has decided to adopt the perl style guide as
published by Larry Wall. This giude can be found in <quote>Programming
Perl</quote> (the camel book) or by typing <command>man perlstyle</command> at
your favorite shell prompt.
</para>
<para>
What appears below if a brief summary, please refer to the perl style
guide if you don't see your question covered here. It is much better to submit
a patch which fails these criteria than no patch at all, but please try to meet
these minimum standards when submitting code to Bugzilla.
</para>
<itemizedlist>
<listitem>
<para>
Whitespace
</para>
<para>
Bugzilla's preferred indentation is 4 spaces (no tabs, please).
</para>
</listitem>
<listitem>
<para>
Curly braces.
</para>
<para>
The opening brace of a block should be on the same line as the statement
that is causing the block and the closing brace should be at the same
indentation level as that statement, for example:
</para>
<para>
<programlisting>
if ($var) {
print "The variable is true";
}
else {
print "Try again";
}
</programlisting>
</para>
<para>
-- NOT THIS --
</para>
<para>
<programlisting>
if ($var)
{
print "The variable is true";
}
else
{
print "Try again";
}
</programlisting>
</para>
</listitem>
<para>Quicksearch is a new, experimental feature of the 2.12 release. It
consist of two Javascript files, "quicksearch.js" and "localconfig.js",
and two documentation files, "quicksearch.html" and
"quicksearchhack.html"</para>
<listitem>
<para>
Cookies
</para>
<para>
Bugzilla uses cookies to ease the user experience, but no new patches
should <emphasis>require</emphasis> user-side cookies.
</para>
</listitem>
<para>The index.html page has been updated to include the QuickSearch
text box.</para>
<listitem>
<para>
File Names
</para>
<para>
File names for bugzilla code and support documention should be legal across
multiple platforms. <computeroutput>\ / : * ? &quot; &lt; &gt;</computeroutput>
and <computeroutput>|</computeroutput> are all illegal characters for filenames
on various platforms. Also, file names should not have spaces in them as they
can cause confusion in CVS and other mozilla.org utilities.
</para>
</listitem>
<para>To take full advantage of the query power, the Bugzilla maintainer
must edit "localconfig.js" according to the value sets used in the local
installation.</para>
<listitem>
<para>
Javascript dependencies
</para>
<para>
While Bugzilla uses Javascript to make the user experience easier, no patch
to Bugzilla should <emphasis>require</emphasis> Javascript.
</para>
</listitem>
<listitem>
<para>
Patch Format
</para>
<para>
All patches submitted for inclusion into Bugzilla should be in the form of a
<quote>unified diff</quote>. This comes from using <quote>diff -u</quote>
instead of simply <quote>diff</quote> when creating your patch. This will
result in quicker acceptance of the patch.
</para>
</listitem>
<listitem>
<para>
Schema Changes
</para>
<para>
If you make schema changes, you should modify <filename>sanitycheck.cgi</filename>
to support the new schema. All referential columns should be checked.
</para>
</listitem>
<para>Currently, keywords must be hard-coded in localconfig.js. If they
are not, keywords are not automatically recognized. This means, if
localconfig.js is left unconfigured, that searching for a bug with the
"foo" keyword will only find bugs with "foo" in the summary, status
whiteboard, product or component name, but not those with the keyword
"foo".</para>
<listitem>
<para>
Taint Mode
</para>
<para>
All new cgis must run in Taint mode (Perl taint and DBI taint), and existing cgi's
which run in taint mode must not have taint mode turned off.
</para>
</listitem>
<para>Workarounds for Bugzilla users:
<simplelist>
<member>search for '!foo' (this will find only bugs with the keyword
"foo"</member>
<listitem>
<para>
Templatization
</para>
<para>
Patches to Bugzilla need to support templates so they do not force user interface choices
on Bugzilla administrators.
<member>search 'foo,!foo' (equivalent to 'foo OR keyword:foo')</member>
</simplelist>
</para>
</listitem>
<listitem>
<para>
Variable Names
</para>
<para>
If a variable is scoped globally (<computeroutput>$::variable</computeroutput>)
its name should be descriptive of what it contains. Local variables can be named
a bit looser, provided the context makes their content obvious. For example,
<computeroutput>$ret</computeroutput> could be used as a staging variable for a
routine's return value as the line <computeroutput>return $ret;</computeroutput>
will make it blatantly obvious what the variable holds and most likely be shown
on the same screen as <computeroutput>my $ret = "";</computeroutput>.
</para>
</listitem>
<para>When this tool is ported from client-side JavaScript to server-side
Perl, the requirement for hard-coding keywords can be fixed.
<ulink url="http://bugzilla.mozilla.org/show_bug.cgi?id=70907">This
bug</ulink>
<listitem>
<para>
Cross Database Compatability
</para>
<para>
Bugzilla was originally written to work with MySQL and therefore took advantage
of some of its features that aren't contained in other RDBMS software. These
should be avoided in all new code. Examples of these features are enums and
<function>encrypt()</function>.
</para>
</listitem>
<listitem>
<para>
Cross Platform Compatability
</para>
<para>
While Bugzilla was written to be used on Unix based systems (and Unix/Linux is
still the only officially supported platform) there are many who desire/need to
run Bugzilla on Microsoft Windows boxes. Whenever possible, we should strive
not to make the lives of these people any more complicated and avoid doing things
that break Bugzilla's ability to run on multiple operating systems.
</para>
</listitem>
</itemizedlist>
</section>
has details.</para>
</section>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -496,3 +303,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/requiredsoftware.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="downloadlinks">
<title>Software Download Links</title>
<para>
All of these sites are current as of April, 2001. Hopefully
they'll stay current for a while.
</para>
<para>
Apache Web Server: <ulink url="http://www.apache.org/">http://www.apache.org</ulink>
Optional web server for Bugzilla, but recommended because of broad user base and support.
</para>
<para>
Bugzilla: <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink>
<para>All of these sites are current as of April, 2001. Hopefully they'll
stay current for a while.</para>
<para>Apache Web Server:
<ulink url="http://www.apache.org/">http://www.apache.org</ulink>
Optional web server for Bugzilla, but recommended because of broad user
base and support.</para>
<para>Bugzilla:
<ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink>
</para>
<para>
MySQL: <ulink url="http://www.mysql.com/">http://www.mysql.com/</ulink>
<para>MySQL:
<ulink url="http://www.mysql.com/">http://www.mysql.com/</ulink>
</para>
<para>
Perl: <ulink url="http://www.perl.org">http://www.perl.org/</ulink>
<para>Perl:
<ulink url="http://www.perl.org">http://www.perl.org/</ulink>
</para>
<para>
CPAN: <ulink url="http://www.cpan.org/">http://www.cpan.org/</ulink>
<para>CPAN:
<ulink url="http://www.cpan.org/">http://www.cpan.org/</ulink>
</para>
<para>
DBI Perl module:
<para>DBI Perl module:
<ulink url="http://www.cpan.org/modules/by-module/DBI/">
http://www.cpan.org/modules/by-module/DBI/</ulink>
</para>
<para>
Data::Dumper module:
<para>Data::Dumper module:
<ulink url="http://www.cpan.org/modules/by-module/Data/">
http://www.cpan.org/modules/by-module/Data/</ulink>
</para>
<para>
MySQL related Perl modules:
<para>MySQL related Perl modules:
<ulink url="http://www.cpan.org/modules/by-module/Mysql/">
http://www.cpan.org/modules/by-module/Mysql/</ulink>
</para>
<para>
TimeDate Perl module collection:
<para>TimeDate Perl module collection:
<ulink url="http://www.cpan.org/modules/by-module/Date/">
http://www.cpan.org/modules/by-module/Date/</ulink>
</para>
<para>
GD Perl module:
<para>GD Perl module:
<ulink url="http://www.cpan.org/modules/by-module/GD/">
http://www.cpan.org/modules/by-module/GD/</ulink>
Alternately, you should be able to find the latest version of
GD at <ulink url="http://www.boutell.com/gd/">http://www.boutell.com/gd/</ulink>
Alternately, you should be able to find the latest version of GD at
<ulink url="http://www.boutell.com/gd/">http://www.boutell.com/gd/</ulink>
</para>
<para>
Chart::Base module:
<para>Chart::Base module:
<ulink url="http://www.cpan.org/modules/by-module/Chart/">
http://www.cpan.org/modules/by-module/Chart/</ulink>
</para>
<para>
LinuxDoc Software:
<ulink url="http://www.linuxdoc.org/">http://www.linuxdoc.org/</ulink>
(for documentation maintenance)
</para>
<para>(But remember, Bundle::Bugzilla will install all the modules for you.)
</para>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -84,3 +85,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/using.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<!-- TOC
Chapter: Using Bugzilla
Create an account
......@@ -26,668 +25,611 @@ Chapter: Using Bugzilla
Miscellaneous usage hints
-->
<chapter id="using">
<title>Using Bugzilla</title>
<epigraph>
<para>
What, Why, How, &amp; Where?
</para>
</epigraph>
<title>Using Bugzilla</title>
<section id="whatis">
<title>What is Bugzilla?</title>
<para>
Bugzilla is one example of a class of programs called "Defect
Tracking Systems", or, more commonly, "Bug-Tracking Systems". Defect
Tracking Systems allow individual or groups of developers to keep
track of outstanding bugs in their product effectively. Bugzilla was
originally written by Terry Weissman in a programming language called
"TCL", to replace a crappy bug-tracking database used internally by
Netscape Communications. Terry later ported Bugzilla to Perl from
TCL, and in Perl it remains to this day. Most commercial
defect-tracking software vendors at the time charged enormous
licensing fees, and Bugzilla quickly became a favorite of the
open-source crowd (with its genesis in the open-source browser
project, Mozilla). It is now the de-facto standard defect-tracking
system against which all others are measured.
</para>
<para>
Bugzilla has matured immensely, and now boasts many advanced features. These include:
<para>Bugzilla is one example of a class of programs called "Defect
Tracking Systems", or, more commonly, "Bug-Tracking Systems". Defect
Tracking Systems allow individual or groups of developers to keep track
of outstanding bugs in their product effectively. Bugzilla was originally
written by Terry Weissman in a programming language called "TCL", to
replace a crappy bug-tracking database used internally by Netscape
Communications. Terry later ported Bugzilla to Perl from TCL, and in Perl
it remains to this day. Most commercial defect-tracking software vendors
at the time charged enormous licensing fees, and Bugzilla quickly became
a favorite of the open-source crowd (with its genesis in the open-source
browser project, Mozilla). It is now the de-facto standard
defect-tracking system against which all others are measured.</para>
<para>Bugzilla has matured immensely, and now boasts many advanced
features. These include:
<itemizedlist>
<listitem>
<para>Powerful searching</para>
</listitem>
<listitem>
<para>User-configurable email notifications of bug changes</para>
</listitem>
<listitem><para>Powerful searching</para></listitem>
<listitem><para>User-configurable email notifications of bug changes</para></listitem>
<listitem><para>Full change history</para></listitem>
<listitem><para>Inter-bug dependency tracking and graphing</para></listitem>
<listitem><para>Excellent attachment management</para></listitem>
<listitem><para>Integrated, product-based, granular security schema</para></listitem>
<listitem><para>Fully security-audited, and runs under Perl's taint mode</para></listitem>
<listitem><para>A robust, stable RDBMS back-end</para></listitem>
<listitem><para>Web, XML, email and console interfaces</para></listitem>
<listitem><para>Completely customisable and/or localisable web user interface</para></listitem>
<listitem><para>Extensive configurability</para></listitem>
<listitem><para>Smooth upgrade pathway between versions</para></listitem>
<listitem>
<para>Full change history</para>
</listitem>
<listitem>
<para>Inter-bug dependency tracking and graphing</para>
</listitem>
<listitem>
<para>Excellent attachment management</para>
</listitem>
<listitem>
<para>Integrated, product-based, granular security schema</para>
</listitem>
<listitem>
<para>Fully security-audited, and runs under Perl's taint mode</para>
</listitem>
<listitem>
<para>A robust, stable RDBMS back-end</para>
</listitem>
<listitem>
<para>Web, XML, email and console interfaces</para>
</listitem>
<listitem>
<para>Completely customisable and/or localisable web user
interface</para>
</listitem>
<listitem>
<para>Extensive configurability</para>
</listitem>
<listitem>
<para>Smooth upgrade pathway between versions</para>
</listitem>
</itemizedlist>
</para>
</section>
<section id="why">
<title>Why Should We Use Bugzilla?</title>
<epigraph>
<para>
No, Who's on first...
</para>
</epigraph>
<para>
For many years, defect-tracking software has remained
principally the domain of large software development houses.
Even then, most shops never bothered with bug-tracking software,
and instead simply relied on shared lists and email to monitor
the status of defects. This procedure is error-prone and tends
to cause those bugs judged least significant by developers to be
dropped or ignored.
</para>
<para>
These days, many companies are finding that integrated
defect-tracking systems reduce downtime, increase productivity,
and raise customer satisfaction with their systems. Along with
full disclosure, an open bug-tracker allows manufacturers to
keep in touch with their clients and resellers, to communicate
about problems effectively throughout the data management chain.
Many corporations have also discovered that defect-tracking
helps reduce costs by providing IT support accountability,
telephone support knowledge bases, and a common, well-understood
system for accounting for unusual system or software issues.
</para>
<para>
But why should <emphasis>you</emphasis> use Bugzilla?
</para>
<para>
Bugzilla is very adaptable to various situations. Known uses
currently include IT support queues, Systems Administration
deployment management, chip design and development problem
tracking (both pre-and-post fabrication), and software and
hardware bug tracking for luminaries such as Redhat, Loki
software, Linux-Mandrake, and VA Systems. Combined with systems
such as CVS, Bonsai, or Perforce SCM, Bugzilla provides a
powerful, easy-to-use solution to configuration management and
replication problems
</para>
<para>
Bugzilla can dramatically increase the productivity and
accountability of individual employees by providing a documented
workflow and positive feedback for good performance. How many
times do you wake up in the morning, remembering that you were
supposed to do <emphasis>something</emphasis> today, but you
just can't quite remember? Put it in Bugzilla, and you have a
record of it from which you can extrapolate milestones, predict
<para>For many years, defect-tracking software has remained principally
the domain of large software development houses. Even then, most shops
never bothered with bug-tracking software, and instead simply relied on
shared lists and email to monitor the status of defects. This procedure
is error-prone and tends to cause those bugs judged least significant by
developers to be dropped or ignored.</para>
<para>These days, many companies are finding that integrated
defect-tracking systems reduce downtime, increase productivity, and raise
customer satisfaction with their systems. Along with full disclosure, an
open bug-tracker allows manufacturers to keep in touch with their clients
and resellers, to communicate about problems effectively throughout the
data management chain. Many corporations have also discovered that
defect-tracking helps reduce costs by providing IT support
accountability, telephone support knowledge bases, and a common,
well-understood system for accounting for unusual system or software
issues.</para>
<para>But why should
<emphasis>you</emphasis>
use Bugzilla?</para>
<para>Bugzilla is very adaptable to various situations. Known uses
currently include IT support queues, Systems Administration deployment
management, chip design and development problem tracking (both
pre-and-post fabrication), and software and hardware bug tracking for
luminaries such as Redhat, Loki software, Linux-Mandrake, and VA Systems.
Combined with systems such as CVS, Bonsai, or Perforce SCM, Bugzilla
provides a powerful, easy-to-use solution to configuration management and
replication problems</para>
<para>Bugzilla can dramatically increase the productivity and
accountability of individual employees by providing a documented workflow
and positive feedback for good performance. How many times do you wake up
in the morning, remembering that you were supposed to do
<emphasis>something</emphasis>
today, but you just can't quite remember? Put it in Bugzilla, and you
have a record of it from which you can extrapolate milestones, predict
product versions for integration, and by using Bugzilla's e-mail
integration features be able to follow the discussion trail that
led to critical decisions.
</para>
<para>
Ultimately, Bugzilla puts the power in your hands to improve
your value to your employer or business while providing a usable
framework for your natural attention to detail and knowledge
store to flourish.
</para>
integration features be able to follow the discussion trail that led to
critical decisions.</para>
<para>Ultimately, Bugzilla puts the power in your hands to improve your
value to your employer or business while providing a usable framework for
your natural attention to detail and knowledge store to flourish.</para>
</section>
<section id="how">
<title>How do I use Bugzilla?</title>
<epigraph>
<para>
Hey! I'm Woody! Howdy, Howdy, Howdy!
</para>
</epigraph>
<para>
This section contains information for end-users of Bugzilla.
If you are administering a Bugzilla installation, please consult the
Installing and Administering Bugzilla portions of this Guide.
</para>
<para>
There is a Bugzilla test installation, called
<ulink url="http://landfill.tequilarista.org/">
Landfill</ulink>, which you are welcome to play with.
However, it does not necessarily have all Bugzilla features
enabled, and often runs cutting-edge versions of Bugzilla for
testing, so some things may work slightly differently than
mentioned here.
</para>
<para>This section contains information for end-users of Bugzilla. If you
are administering a Bugzilla installation, please consult the Installing
and Administering Bugzilla portions of this Guide.</para>
<para>There is a Bugzilla test installation, called
<ulink url="http://landfill.tequilarista.org/">Landfill</ulink>
, which you are welcome to play with. However, it does not necessarily
have all Bugzilla features enabled, and often runs cutting-edge versions
of Bugzilla for testing, so some things may work slightly differently
than mentioned here.</para>
<section id="myaccount">
<title>Create a Bugzilla Account</title>
<para>
If you want to use Bugzilla, first you
need to create an account. Consult with the administrator
responsible for your installation of Bugzilla for the URL you
should use to access it. If you're test-driving Bugzilla,
use this URL: <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/"> http://landfill.tequilarista.org/bugzilla-tip/</ulink>
<para>If you want to use Bugzilla, first you need to create an account.
Consult with the administrator responsible for your installation of
Bugzilla for the URL you should use to access it. If you're
test-driving Bugzilla, use this URL:
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/">
http://landfill.tequilarista.org/bugzilla-tip/</ulink>
</para>
<orderedlist>
<listitem>
<para>
Click the <quote>Open a new Bugzilla account</quote> link, enter your
email address and, optionally, your name in the spaces provided,
then click <quote>Create Account</quote>.
</para>
<para>Click the
<quote>Open a new Bugzilla account</quote>
link, enter your email address and, optionally, your name in the
spaces provided, then click
<quote>Create Account</quote>
.</para>
</listitem>
<listitem>
<para>
Within moments, you should receive an email to the address
you provided above, which contains your login name
(generally the same as the email address), and a password
you can use to access your account. This password is
randomly generated, and can be changed to something more memorable.
</para>
<para>Within moments, you should receive an email to the address
you provided above, which contains your login name (generally the
same as the email address), and a password you can use to access
your account. This password is randomly generated, and can be
changed to something more memorable.</para>
</listitem>
<listitem>
<para>
Click the <quote>Log In</quote> link in the yellow area at
the bottom of the page in your browser, enter your
email address and password into the spaces provided, and click
<quote>Login</quote>.
</para>
<para>Click the
<quote>Log In</quote>
link in the yellow area at the bottom of the page in your browser,
enter your email address and password into the spaces provided, and
click
<quote>Login</quote>
.</para>
</listitem>
</orderedlist>
<para>
You are now logged in. Bugzilla uses cookies for authentication, so
(unless your IP address changes) you should not have to log in again.
</para>
<para>You are now logged in. Bugzilla uses cookies for authentication,
so (unless your IP address changes) you should not have to log in
again.</para>
</section>
<section id="bug_page">
<title>Anatomy of a Bug</title>
<para>
The core of Bugzilla is the screen which displays a particular bug.
It's a good place to explain some Bugzilla concepts.
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/show_bug.cgi?id=1">Bug 1 on Landfill</ulink> is a good example. Note that the names of most fields
are hyperlinks; clicking them will take you to context-sensitive
help on that particular field.
</para>
<para>The core of Bugzilla is the screen which displays a particular
bug. It's a good place to explain some Bugzilla concepts.
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/show_bug.cgi?id=1">
Bug 1 on Landfill</ulink>
is a good example. Note that the names of most fields are hyperlinks;
clicking them will take you to context-sensitive help on that
particular field.</para>
<orderedlist>
<listitem>
<para>
<emphasis>Product and Component</emphasis>:
Bugs are divided up by Product and Component, with a Product having one
or more Components in it. For example, bugzilla.mozilla.org's
"Bugzilla" Product is composed of several Components:
<emphasis>Product and Component</emphasis>
: Bugs are divided up by Product and Component, with a Product
having one or more Components in it. For example,
bugzilla.mozilla.org's "Bugzilla" Product is composed of several
Components:
<simplelist>
<member><emphasis>Administration</emphasis>,
Administration of a bugzilla installation, including
<filename>editcomponents.cgi</filename>,
<filename>editgroups.cgi</filename>,
<filename>editkeywords.cgi</filename>,
<filename>editparams.cgi</filename>,
<filename>editproducts.cgi</filename>,
<filename>editusers.cgi</filename>,
<filename>editversions.cgi,</filename> and
<filename>sanitycheck.cgi</filename>.
</member>
<member><emphasis>Bugzilla-General</emphasis>,
<member>
<emphasis>Administration:</emphasis>
Administration of a Bugzilla installation.</member>
<member>
<emphasis>Bugzilla-General:</emphasis>
Anything that doesn't fit in the other components, or spans
multiple components.
</member>
<member><emphasis>Creating/Changing Bugs</emphasis>,
Creating, changing, and viewing bugs.
<filename>enter_bug.cgi</filename>,
<filename>post_bug.cgi</filename>,
<filename>show_bug.cgi</filename> and
<filename>process_bug.cgi</filename>.
</member>
<member><emphasis>Documentation</emphasis>,
The bugzilla documentation, including anything in the
<filename>docs/</filename> directory and The Bugzilla Guide
</member>
<member><emphasis>Email</emphasis>,
Anything to do with email sent by Bugzilla.
<filename>processmail</filename>
</member>
<member><emphasis>Installation</emphasis>,
The installation process of Bugzilla. This includes
<filename>checksetup.pl</filename> and whatever else it evolves into.
</member>
<member><emphasis>Query/Buglist</emphasis>,
Anything to do with searching for bugs and viewing the buglists.
<filename>query.cgi</filename> and
<filename>buglist.cgi</filename>
</member>
<member><emphasis>Reporting/Charting</emphasis>,
Getting reports from Bugzilla.
<filename>reports.cgi</filename> and
<filename>duplicates.cgi</filename>
</member>
<member><emphasis>User Accounts</emphasis>,
multiple components.</member>
<member>
<emphasis>Creating/Changing Bugs:</emphasis>
Creating, changing, and viewing bugs.</member>
<member>
<emphasis>Documentation:</emphasis>
The Bugzilla documentation, including The Bugzilla Guide.</member>
<member>
<emphasis>Email:</emphasis>
Anything to do with email sent by Bugzilla.</member>
<member>
<emphasis>Installation:</emphasis>
The installation process of Bugzilla.</member>
<member>
<emphasis>Query/Buglist:</emphasis>
Anything to do with searching for bugs and viewing the
buglists.</member>
<member>
<emphasis>Reporting/Charting:</emphasis>
Getting reports from Bugzilla.</member>
<member>
<emphasis>User Accounts:</emphasis>
Anything about managing a user account from the user's perspective.
<filename>userprefs.cgi</filename>, saved queries, creating accounts,
changing passwords, logging in, etc.
</member>
<member><emphasis>User Interface</emphasis>,
Saved queries, creating accounts, changing passwords, logging in,
etc.</member>
<member>
<emphasis>User Interface:</emphasis>
General issues having to do with the user interface cosmetics (not
functionality) including cosmetic issues, HTML templates, etc.
</member>
functionality) including cosmetic issues, HTML templates,
etc.</member>
</simplelist>
</para>
</listitem>
<listitem>
<para>
<emphasis>Status and Resolution</emphasis>:
A bug passes through several Statuses in its lifetime, and ends up in the
RESOLVED status, with one of a set of Resolutions (e.g. FIXED, INVALID.)
The different possible
values for Status and Resolution on your installation will be documented
in the context-sensitive help for those items.
</para>
<emphasis>Status and Resolution:</emphasis>
A bug passes through several Statuses in its lifetime, and ends up
in the RESOLVED status, with one of a set of Resolutions (e.g.
FIXED, INVALID.) The different possible values for Status and
Resolution on your installation will be documented in the
context-sensitive help for those items.</para>
</listitem>
<listitem>
<para>
<emphasis>Assigned To</emphasis>:
The person responsible for fixing the bug.
</para>
<emphasis>Assigned To:</emphasis>
The person responsible for fixing the bug.</para>
</listitem>
<listitem>
<para>
<emphasis>URL</emphasis>:
A URL associated with the bug, if any.
</para>
<emphasis>URL:</emphasis>
A URL associated with the bug, if any.</para>
</listitem>
<listitem>
<para>
<emphasis>Summary</emphasis>:
A one-sentence summary of the problem.
</para>
<emphasis>Summary:</emphasis>
A one-sentence summary of the problem.</para>
</listitem>
<listitem>
<para>
<emphasis>Status Whiteboard</emphasis>: (a.k.a. Whiteboard) A
free-form text area for adding short notes and tags to a bug.
</para>
<emphasis>Status Whiteboard:</emphasis>
(a.k.a. Whiteboard) A free-form text area for adding short notes
and tags to a bug.</para>
</listitem>
<listitem>
<para>
<emphasis>Keywords</emphasis>:
<emphasis>Keywords:</emphasis>
The administrator can define keywords which you can use to tag and
categorise bugs - e.g. The Mozilla Project has keywords like crash
and regression.
</para>
and regression.</para>
</listitem>
<listitem>
<para>
<emphasis>Platform and OS</emphasis>:
These indicate the computing environment where the bug was found.
</para>
<emphasis>Platform and OS:</emphasis>
These indicate the computing environment where the bug was
found.</para>
</listitem>
<listitem>
<para>
<emphasis>Version</emphasis>:
The "Version" field is usually used for versions of a product which have
been released, and is set to indicate which versions of a Component
have the particular problem the bug report is about.
</para>
<emphasis>Version:</emphasis>
The "Version" field is usually used for versions of a product which
have been released, and is set to indicate which versions of a
Component have the particular problem the bug report is
about.</para>
</listitem>
<listitem>
<para>
<emphasis>Priority</emphasis>:
The bug assignee uses this field to prioritise his or her bugs. It's
a good idea not to change this on other people's bugs.
</para>
<emphasis>Priority:</emphasis>
The bug assignee uses this field to prioritise his or her bugs.
It's a good idea not to change this on other people's bugs.</para>
</listitem>
<listitem>
<para>
<emphasis>Severity</emphasis>:
This indicates how severe the problem is - from blocker ("application
unusable") to trivial ("minor cosmetic issue"). You can also use this
field to indicate whether a bug is an enhancement request.
</para>
<emphasis>Severity:</emphasis>
This indicates how severe the problem is - from blocker
("application unusable") to trivial ("minor cosmetic issue"). You
can also use this field to indicate whether a bug is an enhancement
request.</para>
</listitem>
<listitem>
<para>
<emphasis>Target</emphasis>:
(a.k.a. Target Milestone) A future version by which the bug is to be
fixed. e.g. The Bugzilla Project's milestones for future
Bugzilla versions are 2.18, 2.20, 3.0, etc. Milestones are
not restricted to numbers, thought - you can use any text strings,
such as dates.
</para>
<emphasis>Target:</emphasis>
(a.k.a. Target Milestone) A future version by which the bug is to
be fixed. e.g. The Bugzilla Project's milestones for future
Bugzilla versions are 2.18, 2.20, 3.0, etc. Milestones are not
restricted to numbers, thought - you can use any text strings, such
as dates.</para>
</listitem>
<listitem>
<para>
<emphasis>Reporter</emphasis>:
The person who filed the bug.
</para>
<emphasis>Reporter:</emphasis>
The person who filed the bug.</para>
</listitem>
<listitem>
<para>
<emphasis>CC list</emphasis>:
A list of people who get mail when the bug changes.
</para>
<emphasis>CC list:</emphasis>
A list of people who get mail when the bug changes.</para>
</listitem>
<listitem>
<para>
<emphasis>Attachments</emphasis>:
You can attach files (e.g. testcases or patches) to bugs. If there are
any attachments, they are listed in this section.
</para>
<emphasis>Attachments:</emphasis>
You can attach files (e.g. testcases or patches) to bugs. If there
are any attachments, they are listed in this section.</para>
</listitem>
<listitem>
<para>
<emphasis>Dependencies</emphasis>:
If this bug cannot be fixed unless other bugs are fixed (depends on), or
this bug stops other bugs being fixed (blocks), their numbers are
recorded here.
</para>
<emphasis>Dependencies:</emphasis>
If this bug cannot be fixed unless other bugs are fixed (depends
on), or this bug stops other bugs being fixed (blocks), their
numbers are recorded here.</para>
</listitem>
<listitem>
<para>
<emphasis>Votes</emphasis>:
Whether this bug has any votes.
</para>
<emphasis>Votes:</emphasis>
Whether this bug has any votes.</para>
</listitem>
<listitem>
<para>
<emphasis>Additional Comments</emphasis>:
<emphasis>Additional Comments:</emphasis>
You can add your two cents to the bug discussion here, if you have
something worthwhile to say.
</para>
something worthwhile to say.</para>
</listitem>
</orderedlist>
</section>
<section id="query">
<title>Searching for Bugs</title>
<para>
The Bugzilla Search page is is the interface where you can
find any bug report, comment, or patch currently in the
Bugzilla system. You can play with it here:
<para>The Bugzilla Search page is is the interface where you can find
any bug report, comment, or patch currently in the Bugzilla system. You
can play with it here:
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi">
landfill.tequilarista.org/bugzilla-tip/query.cgi</ulink>.
</para>
landfill.tequilarista.org/bugzilla-tip/query.cgi</ulink>
<para>
The Search page has controls for selecting different possible values
for all of the fields in a bug, as described above. Once you've defined
a search, you can either run it, or save it as a Remembered Query, which
can optionally appear in the footer of your pages.
</para>
.</para>
<para>
Highly advanced querying is done using Boolean Charts, which have their
own <ulink url="http://landfill.tequilarista.org/bugzilla-tip/booleanchart.html">context-sensitive help</ulink>.
</para>
<para>The Search page has controls for selecting different possible
values for all of the fields in a bug, as described above. Once you've
defined a search, you can either run it, or save it as a Remembered
Query, which can optionally appear in the footer of your pages.</para>
<para>Highly advanced querying is done using Boolean Charts, which have
their own
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/booleanchart.html">
context-sensitive help</ulink>
.</para>
</section>
<section id="list">
<title>Bug Lists</title>
<para>
If you run a search, a list of matching bugs will be returned.
The default search is to return all open bugs on the system -
don't try running this search on a Bugzilla installation with
a lot of bugs!
</para>
<para>
The format of the list is configurable. For example, it can be
sorted by clicking the column headings. Other useful features
can be accessed using the links at the bottom of the list:
<para>If you run a search, a list of matching bugs will be returned.
The default search is to return all open bugs on the system - don't try
running this search on a Bugzilla installation with a lot of
bugs!</para>
<para>The format of the list is configurable. For example, it can be
sorted by clicking the column headings. Other useful features can be
accessed using the links at the bottom of the list:
<simplelist>
<member><emphasis>Long Format</emphasis>: this gives you a large page
with a non-editable summary of the fields of each bug.</member>
<member><emphasis>Change Columns</emphasis>: change the bug
attributes which appear in the list.</member>
<member><emphasis>Change several bugs at once</emphasis>: If
your account is sufficiently empowered, you can make the same
<member>
<emphasis>Long Format:</emphasis>
this gives you a large page with a non-editable summary of the fields
of each bug.</member>
<member>
<emphasis>Change Columns:</emphasis>
change the bug attributes which appear in the list.</member>
<member>
<emphasis>Change several bugs at once:</emphasis>
If your account is sufficiently empowered, you can make the same
change to all the bugs in the list - for example, changing their
owner.</member>
<member><emphasis>Send mail to bug owners</emphasis>: Sends mail
to the owners of all bugs on the list.</member>
<member><emphasis>Edit this query</emphasis>: If you didn't
get exactly the results you were looking for, you can
return to the Query page through this link and make small
revisions to the query you just made so you get more
accurate results.</member>
<member>
<emphasis>Send mail to bug owners:</emphasis>
Sends mail to the owners of all bugs on the list.</member>
<member>
<emphasis>Edit this query:</emphasis>
If you didn't get exactly the results you were looking for, you can
return to the Query page through this link and make small revisions
to the query you just made so you get more accurate results.</member>
</simplelist>
</para>
</section>
<section id="bugreports">
<title>Filing Bugs</title>
<epigraph>
<para>And all this time, I thought we were taking bugs <emphasis>out</emphasis>...</para>
</epigraph>
<para>
Years of bug writing experience has been distilled for your reading
pleasure into the <ulink url="http://landfill.tequilarista.org/bugzilla-tip/bugwritinghelp.html">
Bug Writing Guidelines</ulink>.
While some of the advice is Mozilla-specific, the basic principles of reporting Reproducible, Specific bugs, isolating the Product you are using, the Version of the Product, the Component which failed, the Hardware Platform, and Operating System you were using at the time of the failure go a long way toward ensuring accurate, responsible fixes for the bug that bit you.
</para>
<para>
The procedure for filing a test bug is as follows:
</para>
<para>Years of bug writing experience has been distilled for your
reading pleasure into the
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/bugwritinghelp.html">
Bug Writing Guidelines</ulink>
. While some of the advice is Mozilla-specific, the basic principles of
reporting Reproducible, Specific bugs, isolating the Product you are
using, the Version of the Product, the Component which failed, the
Hardware Platform, and Operating System you were using at the time of
the failure go a long way toward ensuring accurate, responsible fixes
for the bug that bit you.</para>
<para>The procedure for filing a test bug is as follows:</para>
<orderedlist>
<listitem>
<para>
Go to <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/">Landfill</ulink>
<para>Go to
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/">
Landfill</ulink>
in your browser and click
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/enter_bug.cgi"> Enter a new bug report</ulink>.
</para>
url="http://landfill.tequilarista.org/bugzilla-tip/enter_bug.cgi">
Enter a new bug report</ulink>
.</para>
</listitem>
<listitem>
<para>
Select a product - any one will do.
</para>
<para>Select a product - any one will do.</para>
</listitem>
<listitem>
<para>
Fill in the fields.
Bugzilla should have made reasonable guesses, based upon
your browser, for the "Platform" and "OS" drop-down
boxes. If they are wrong, change them.
</para>
<para>Fill in the fields. Bugzilla should have made reasonable
guesses, based upon your browser, for the "Platform" and "OS"
drop-down boxes. If they are wrong, change them.</para>
</listitem>
<listitem>
<para>
Select "Commit" and send in your bug report.
</para>
<para>Select "Commit" and send in your bug report.</para>
</listitem>
</orderedlist>
</section>
</section>
<section id="init4me">
<title>Where can I find my user preferences?</title>
<epigraph>
<para>
Indiana, it feels like we walking on fortune cookies!
</para>
<para>
These ain't fortune cookies, kid...
</para>
</epigraph>
<para>
Customized User Preferences offer tremendous versatility to your
individual Bugzilla experience. Let's plunge into what you can
do! The first step is to click the "Edit prefs" link at the
footer of each page once you have logged in to <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi?GoAheadAndLogIn=1"> Landfill</ulink>.
</para>
<title>User Preferences</title>
<para>You can customise various aspects of Bugzilla, via the "Edit prefs"
link in the page footer, once you have logged in, e.g. to
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi?GoAheadAndLogIn=1">
Landfill</ulink>
. The preferences are split into four tabs.</para>
<section id="accountsettings" xreflabel="Account Settings">
<title>Account Settings</title>
<para>
On this page, you can change your basic Account Settings,
including your password and full name. For security reasons,
in order to change anything on this page you must type your
<emphasis>current</emphasis> password into the <quote>Old
Password</quote> field. If you wish to change your
password, type the new password you want into the <quote>New
Password</quote> field and again into the <quote>Re-enter
new password</quote> field to ensure you typed your new
password correctly. Select the <quote>Submit</quote> button
and you are done.
</para>
<para>On this tab, you can change your basic Account Settings,
including your password, email address and real name. For security
reasons, in order to change anything on this page you must type your
<emphasis>current</emphasis>
password into the
<quote>Password</quote>
field. If you attempt to change your email address, a confirmation
email is sent to both the old and new addresses, with a link to use to
confirm the change. This helps to prevent account hijacking.</para>
</section>
<section id="emailsettings" >
<section id="emailsettings">
<title>Email Settings</title>
<section id="notification" xreflabel="">
<title>Email Notification</title>
<para>
Here you can reduce or increase the amount of email sent you
from Bugzilla. Although this is referred to as
<quote>Advanced Email Filtering Options</quote>, they are,
in fact, the standard email filter set. All of them are
self-explanatory, but you can use the filters in interesting
ways. For instance, some people (notably Quality Assurance
personnel) often only care to receive updates regarding a
bug when the bug changes state, so they can track bugs on
their flow charts and know when it is time to pull the bug
onto a quality assurance platform for inspection. Other
people set up email gateways to
<xref linkend="bonsai" /> or <xref linkend="tinderbox" />, and
restrict which types of Bugzilla information are fed to
these systems..
</para>
</section>
<section id="newemailtech">
<title>New Email Technology</title>
<note>
<para>
This option may not be available in all Bugzilla
installations, depending upon the preferences of the
systems administrator responsible for the setup of your
Bugzilla. However, if you really want this functionality,
ask her to "enable newemailtech in Params" and "make it
the default for all new users", referring her to the
Administration section of this Guide.
</para>
</note>
<para>
Disregard the warnings about "experimental and bleeding
edge"; the code to handle email in a cleaner manner than
that historically used for Bugzilla is quite robust and
well-tested now.
</para>
<para>
I recommend you enable the option, "Click here to sign up
(and risk any bugs)". Your email-box will thank you for it.
The fundamental shift in "newemailtech" is away from
standard UNIX "diff" output, which is quite ugly, to a
prettier, better laid-out email.
</para>
</section>
<section id="watchsettings">
<title>"Watching" Users</title>
<para>On this tab you can reduce or increase the amount of email sent
you from Bugzilla, opting in our out depending on your relationship to
the bug and the change that was made to it. (Note that you can also do
client-side filtering using the X-Bugzilla-Reason header which Bugzilla
adds to all bugmail.)</para>
<para>By entering user email names, delineated by commas, into the
"Users to watch" text entry box you can receive a copy of all the
bugmail of other users (security settings permitting.) This powerful
functionality enables seamless transitions as developers change
projects, managers wish to get in touch with the issues faced by their
direct reports, or users go on vacation.</para>
<note>
<para>
This option may not be available in all Bugzilla
installations, depending upon the preferences of the
systems administrator responsible for the setup of your
Bugzilla. However, if you really want this functionality,
ask her to "enable watchers in Params".
</para>
<para>This option may not be available in all Bugzilla installations.
Ask your administrator.</para>
</note>
<para>
By entering user email names into the "Users to watch" text
entry box, delineated by commas, you can watch bugs of other
users. This powerful functionality enables seamless
transitions as developers change projects, managers wish to
get in touch with the issues faced by their direct reports,
or users go on vacation. If any of these three situations
apply to you, you will undoubtedly find this feature quite
convenient.
</para>
</section>
</section>
<section id="footersettings">
<title>Page Footer</title>
<note>
<para>
By default, this page is quite barren. However, go explore
the Query Page some more; you will find that you can store
numerous queries on the server, so if you regularly run a
particular query it is just a drop-down menu away. On this
page of Preferences, if you have many stored queries you can
elect to have them always one-click away!
</para>
</note>
<para>
If you have many stored queries on the server, here you will
find individual drop-downs for each stored query. Each
drop-down gives you the option of that query appearing on the
footer of every page in Bugzilla! This gives you powerful
one-click access to any complex searches you may set up, and
is an excellent way to impress your boss...
</para>
<tip>
<para>By default, the "My Bugs" link appears at the bottom of
each page. However, this query gives you both the bugs you
have reported, as well as those you are assigned. One of
the most common uses for this page is to remove the "My
Bugs" link, replacing it with two other queries, commonly
called "My Bug Reports" and "My Bugs" (but only referencing
bugs assigned to you). This allows you to distinguish those
bugs you have reported from those you are assigned. I
commonly set up complex Boolean queries in the Query page
and link them to my footer in this page. When they are
significantly complex, a one-click reference can save hours
of work.</para>
</tip>
<para>By default, this page is quite barren. However, if you explore
the Search page some more, you will find that you can store numerous
queries on the server, so if you regularly run a particular query it is
just a drop-down menu away. Once you have a stored query, you can come
here to request that it also be displayed in your page footer.</para>
</section>
<section id="permissionsettings">
<title>Permissions</title>
<para>
This is a purely informative page which outlines your current
permissions on this installation of Bugzilla. If you have
permissions to grant certain permissions to other users, the
"other users" link appears on this page as well as the footer.
For more information regarding user administration, please
consult the Administration section of this Guide.
</para>
</section>
</section>
<section id="usingbz-conc">
<title>Using Bugzilla-Conclusion</title>
<para>
Thank you for reading through this portion of the Bugzilla
Guide. I anticipate it may not yet meet the needs of all
readers. If you have additional comments or corrections to
make, please submit your contributions to the <ulink
url="mailto://mozilla-webtools@mozilla.org">mozilla-webtools</ulink> mailing list/newsgroup. The mailing list is mirrored to the netscape.public.mozilla.webtools newsgroup, and the newsgroup is mirrored to mozilla-webtools@mozilla.org
</para>
<para>This is a purely informative page which outlines your current
permissions on this installation of Bugzilla - what product groups you
are in, and whether you can edit bugs or perform various administration
functions.</para>
</section>
</section>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -708,3 +650,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/sgml/variants.sgml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN">-->
<chapter id="variants" xreflabel="Bugzilla Variants and Competitors">
<title>Bugzilla Variants and Competitors</title>
<para>I created this section to answer questions about Bugzilla
competitors and variants, then found a wonderful site which covers
an awful lot of what I wanted to discuss. Rather than quote it in
its entirety, I'll simply refer you here: <ulink
url="http://linas.org/linux/pm.html">http://linas.org/linux/pm.html</ulink></para>
<para>I created this section to answer questions about Bugzilla competitors
and variants, then found a wonderful site which covers an awful lot of what
I wanted to discuss. Rather than quote it in its entirety, I'll simply
refer you here:
<ulink url="http://linas.org/linux/pm.html">
http://linas.org/linux/pm.html</ulink>
</para>
<section id="rhbugzilla" xreflabel="Red Hat Bugzilla">
<title>Red Hat Bugzilla</title>
<para>
Red Hat Bugzilla is probably the most popular Bugzilla variant
on the planet. One of the major benefits of Red Hat Bugzilla is
the ability to work with Oracle, MySQL, and PostGreSQL databases
serving as the back-end, instead of just MySQL. Dave Lawrence
has worked very hard to keep Red Hat Bugzilla up-to-date, and
many people prefer the snappier-looking page layout of Red Hat
Bugzilla to the default Mozilla-standard formatting.
<para>Red Hat Bugzilla is probably the most popular Bugzilla variant on
the planet. One of the major benefits of Red Hat Bugzilla is the ability
to work with Oracle, MySQL, and PostGreSQL databases serving as the
back-end, instead of just MySQL. Dave Lawrence has worked very hard to
keep Red Hat Bugzilla up-to-date, and many people prefer the
snappier-looking page layout of Red Hat Bugzilla to the default
Mozilla-standard formatting.</para>
<para>URL:
<ulink url="http://bugzilla.redhat.com/bugzilla/">
http://bugzilla.redhat.com/bugzilla/</ulink>
</para>
<para>URL: <ulink
url="http://bugzilla.redhat.com/bugzilla/">http://bugzilla.redhat.com/bugzilla/</ulink></para>
</section>
<section id="variant-fenris" xreflabel="Loki Bugzilla, a.k.a. Fenris">
<title>Loki Bugzilla (Fenris)</title>
<para>Fenris can be found at <ulink
url="http://fenris.lokigames.com/">http://fenris.lokigames.com</ulink>. It is a fork from Bugzilla.</para>
<para>Fenris can be found at
<ulink url="http://fenris.lokigames.com/">
http://fenris.lokigames.com</ulink>
. It is a fork from Bugzilla.</para>
</section>
<section id="variant-issuezilla" xreflabel="Issuezilla">
<title>Issuezilla</title>
<para>Issuezilla is another fork from Bugzilla, and seems nearly
as popular as the Red Hat Bugzilla fork. Some Issuezilla team
members are regular contributors to the Bugzilla mailing
list/newsgroup. Issuezilla is not the primary focus of
bug-tracking at tigris.org, however. Their Java-based
bug-tracker, <xref linkend="variant-scarab" />, is under heavy development
and looks promising!</para>
<para>URL: <ulink url="http://issuezilla.tigris.org/servlets/ProjectHome">http://issuezilla.tigris.org/servlets/ProjectHome</ulink></para>
<para>Issuezilla is another fork from Bugzilla, and seems nearly as
popular as the Red Hat Bugzilla fork. Some Issuezilla team members are
regular contributors to the Bugzilla mailing list/newsgroup. Issuezilla
is not the primary focus of bug-tracking at tigris.org, however. Their
Java-based bug-tracker,
<xref linkend="variant-scarab" />
, is under heavy development and looks promising!</para>
<para>URL:
<ulink url="http://issuezilla.tigris.org/servlets/ProjectHome">
http://issuezilla.tigris.org/servlets/ProjectHome</ulink>
</para>
</section>
<section id="variant-scarab" xreflabel="Scarab, a newfangled Java-based issue tracker">
<section id="variant-scarab"
xreflabel="Scarab, a newfangled Java-based issue tracker">
<title>Scarab</title>
<para>Scarab is a promising new bug-tracking system built using
Java Serlet technology. As of this writing, no source code has
been released as a package, but you can obtain the code from
CVS.
<para>Scarab is a promising new bug-tracking system built using Java
Serlet technology. As of this writing, no source code has been released
as a package, but you can obtain the code from CVS.</para>
<para>URL:
<ulink url="http://scarab.tigris.org/">http://scarab.tigris.org</ulink>
</para>
<para>URL: <ulink url="http://scarab.tigris.org/">http://scarab.tigris.org</ulink></para>
</section>
<section id="variant-perforce" xreflabel="Using Perforce to track bugs">
<title>Perforce SCM</title>
<para>Although Perforce isn't really a bug tracker, it can be used
as such through the <quote>jobs</quote> functionality.</para>
<para><ulink
url="http://www.perforce.com/perforce/technotes/note052.html"></ulink>http://www.perforce.com/perforce/technotes/note052.html</para>
<para>Although Perforce isn't really a bug tracker, it can be used as
such through the
<quote>jobs</quote>
functionality.</para>
<para>
<ulink url="http://www.perforce.com/perforce/technotes/note052.html">
</ulink>
http://www.perforce.com/perforce/technotes/note052.html</para>
</section>
<section id="variant-sourceforge" xreflabel="SourceForge">
<title>SourceForge</title>
<para>SourceForge is more of a way of coordinating geographically
distributed free software and open source projects over the
Internet than strictly a bug tracker, but if you're hunting for
bug-tracking for your open project, it may be just what the
software engineer ordered!</para>
<para>URL: <ulink
url="http://www.sourceforge.net">http://www.sourceforge.net</ulink></para>
</section>
<para>SourceForge is more of a way of coordinating geographically
distributed free software and open source projects over the Internet than
strictly a bug tracker, but if you're hunting for bug-tracking for your
open project, it may be just what the software engineer ordered!</para>
<para>URL:
<ulink url="http://www.sourceforge.net">
http://www.sourceforge.net</ulink>
</para>
</section>
</chapter>
<!-- Keep this comment at the end of the file
......@@ -94,3 +119,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/administration.xml
View file @ 74bcd6f1
This source diff could not be displayed because it is too large. You can view the blob instead.
docs/xml/conventions.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE section PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<section id="conventions">
<title>Document Conventions</title>
......@@ -7,93 +6,151 @@
<primary>conventions</primary>
</indexterm>
<para>
This document uses the following conventions
</para>
<para>This document uses the following conventions</para>
<informaltable frame="none">
<tgroup cols="2">
<thead>
<row>
<entry>Descriptions</entry>
<entry>Appearance</entry>
</row>
</thead>
<tbody>
<row>
<entry>Warnings</entry>
<entry><caution>
<entry>
<caution>
<para>Don't run with scissors!</para>
</caution></entry>
</caution>
</entry>
</row>
<row>
<entry>Hint</entry>
<entry><tip>
<entry>
<tip>
<para>Warm jar lids under the hot tap to loosen them.</para>
</tip></entry>
</tip>
</entry>
</row>
<row>
<entry>Notes</entry>
<entry><note>
<entry>
<note>
<para>Dear John...</para>
</note></entry>
</note>
</entry>
</row>
<row>
<entry>Information requiring special attention</entry>
<entry><warning>
<entry>
<warning>
<para>Read this or the cat gets it.</para>
</warning></entry>
</warning>
</entry>
</row>
<row>
<entry>File Names</entry>
<entry><filename>file.extension</filename></entry>
<entry>
<filename>file.extension</filename>
</entry>
</row>
<row>
<entry>Directory Names</entry>
<entry><filename class="directory">directory</filename></entry>
<entry>
<filename class="directory">directory</filename>
</entry>
</row>
<row>
<entry>Commands to be typed</entry>
<entry><command>command</command></entry>
<entry>
<command>command</command>
</entry>
</row>
<row>
<entry>Applications Names</entry>
<entry><application>application</application></entry>
<entry>
<application>application</application>
</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of users command under bash shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of users command under bash shell</entry>
<entry>bash$</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of root users command under bash shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of root users command under bash shell</entry>
<entry>bash#</entry>
</row>
<row>
<entry><foreignphrase>Prompt</foreignphrase> of user command under tcsh shell</entry>
<entry>
<foreignphrase>Prompt</foreignphrase>
of user command under tcsh shell</entry>
<entry>tcsh$</entry>
</row>
<row>
<entry>Environment Variables</entry>
<entry><envar>VARIABLE</envar></entry>
<entry>
<envar>VARIABLE</envar>
</entry>
</row>
<row>
<entry>Emphasized word</entry>
<entry><emphasis>word</emphasis></entry>
<entry>
<emphasis>word</emphasis>
</entry>
</row>
<row>
<entry>Code Example</entry>
<entry><programlisting><sgmltag class="starttag">para</sgmltag>Beginning and end of paragraph<sgmltag class="endtag">para</sgmltag></programlisting></entry>
<entry>
<programlisting>
<sgmltag class="starttag">para</sgmltag>
Beginning and end of paragraph
<sgmltag class="endtag">para</sgmltag>
</programlisting>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</section>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -114,3 +171,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/database.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="database">
<title>The Bugzilla Database</title>
<title>The Bugzilla Database</title>
<note>
<para>
This document really needs to be updated with more fleshed out information about primary keys, interrelationships, and maybe some nifty tables to document dependencies. Any takers?
</para>
<note>
<para>This document really needs to be updated with more fleshed out
information about primary keys, interrelationships, and maybe some nifty
tables to document dependencies. Any takers?</para>
</note>
<section id="dbschema">
<title>Database Schema Chart</title>
<para>
<mediaobject>
<imageobject>
......@@ -28,332 +29,285 @@
</section>
<section id="dbdoc">
<title>MySQL Bugzilla Database Introduction</title>
<para>
This information comes straight from my life. I was forced to learn how
Bugzilla organizes database because of nitpicky requests from users for tiny
changes in wording, rather than having people re-educate themselves or
figure out how to work our procedures around the tool. It sucks, but it can
and will happen to you, so learn how the schema works and deal with it when it
comes.
</para>
<para>
So, here you are with your brand-new installation of Bugzilla. You've got
MySQL set up, Apache working right, Perl DBI and DBD talking to the database
flawlessly. Maybe you've even entered a few test bugs to make sure email's
working; people seem to be notified of new bugs and changes, and you can
enter and edit bugs to your heart's content. Perhaps you've gone through the
trouble of setting up a gateway for people to submit bugs to your database via
email, have had a few people test it, and received rave reviews from your beta
testers.
</para>
<para>
What's the next thing you do? Outline a training strategy for your
development team, of course, and bring them up to speed on the new tool you've
labored over for hours.
</para>
<para>
Your first training session starts off very well! You have a captive
audience which seems enraptured by the efficiency embodied in this thing called
"Bugzilla". You are caught up describing the nifty features, how people can
save favorite queries in the database, set them up as headers and footers on
their pages, customize their layouts, generate reports, track status with
greater efficiency than ever before, leap tall buildings with a single bound
and rescue Jane from the clutches of Certain Death!
</para>
<para>
But Certain Death speaks up -- a tiny voice, from the dark corners of the
conference room. "I have a concern," the voice hisses from the darkness,
"about the use of the word 'verified'.
</para>
<para>
The room, previously filled with happy chatter, lapses into reverential
silence as Certain Death (better known as the Vice President of Software
Engineering) continues. "You see, for two years we've used the word 'verified'
to indicate that a developer or quality assurance engineer has confirmed that,
in fact, a bug is valid. I don't want to lose two years of training to a
new software product. You need to change the bug status of 'verified' to
'approved' as soon as possible. To avoid confusion, of course."
</para>
<para>
Oh no! Terror strikes your heart, as you find yourself mumbling "yes, yes, I
don't think that would be a problem," You review the changes with Certain
Death, and continue to jabber on, "no, it's not too big a change. I mean, we
have the source code, right? You know, 'Use the Source, Luke' and all that...
no problem," All the while you quiver inside like a beached jellyfish bubbling,
burbling, and boiling on a hot Jamaican sand dune...
</para>
<para>
Thus begins your adventure into the heart of Bugzilla. You've been forced
to learn about non-portable enum() fields, varchar columns, and tinyint
definitions. The Adventure Awaits You!
</para>
<title>MySQL Bugzilla Database Introduction</title>
<para>This information comes straight from my life. I was forced to learn
how Bugzilla organizes database because of nitpicky requests from users
for tiny changes in wording, rather than having people re-educate
themselves or figure out how to work our procedures around the tool. It
sucks, but it can and will happen to you, so learn how the schema works
and deal with it when it comes.</para>
<para>So, here you are with your brand-new installation of Bugzilla.
You've got MySQL set up, Apache working right, Perl DBI and DBD talking
to the database flawlessly. Maybe you've even entered a few test bugs to
make sure email's working; people seem to be notified of new bugs and
changes, and you can enter and edit bugs to your heart's content. Perhaps
you've gone through the trouble of setting up a gateway for people to
submit bugs to your database via email, have had a few people test it,
and received rave reviews from your beta testers.</para>
<para>What's the next thing you do? Outline a training strategy for your
development team, of course, and bring them up to speed on the new tool
you've labored over for hours.</para>
<para>Your first training session starts off very well! You have a
captive audience which seems enraptured by the efficiency embodied in
this thing called "Bugzilla". You are caught up describing the nifty
features, how people can save favorite queries in the database, set them
up as headers and footers on their pages, customize their layouts,
generate reports, track status with greater efficiency than ever before,
leap tall buildings with a single bound and rescue Jane from the clutches
of Certain Death!</para>
<para>But Certain Death speaks up -- a tiny voice, from the dark corners
of the conference room. "I have a concern," the voice hisses from the
darkness, "about the use of the word 'verified'.</para>
<para>The room, previously filled with happy chatter, lapses into
reverential silence as Certain Death (better known as the Vice President
of Software Engineering) continues. "You see, for two years we've used
the word 'verified' to indicate that a developer or quality assurance
engineer has confirmed that, in fact, a bug is valid. I don't want to
lose two years of training to a new software product. You need to change
the bug status of 'verified' to 'approved' as soon as possible. To avoid
confusion, of course."</para>
<para>Oh no! Terror strikes your heart, as you find yourself mumbling
"yes, yes, I don't think that would be a problem," You review the changes
with Certain Death, and continue to jabber on, "no, it's not too big a
change. I mean, we have the source code, right? You know, 'Use the
Source, Luke' and all that... no problem," All the while you quiver
inside like a beached jellyfish bubbling, burbling, and boiling on a hot
Jamaican sand dune...</para>
<para>Thus begins your adventure into the heart of Bugzilla. You've been
forced to learn about non-portable enum() fields, varchar columns, and
tinyint definitions. The Adventure Awaits You!</para>
<section>
<title>Bugzilla Database Basics</title>
<para>
If you were like me, at this point you're totally clueless
about the internals of MySQL, and if it weren't for this
executive order from the Vice President you couldn't care less
about the difference between a <quote>bigint</quote> and a
<quote>tinyint</quote> entry in MySQL. I recommend you refer
to the MySQL documentation, available at <ulink url="http://www.mysql.com/doc.html">MySQL.com</ulink>. Below are the basics you need to know about the Bugzilla database. Check the chart above for more details.
</para>
<para><orderedlist>
<listitem>
<para>
To connect to your database:
</para>
<para>
<prompt>bash#</prompt><command>mysql</command><parameter>-u root</parameter>
</para>
<para>
If this works without asking you for a password,
<emphasis>shame on you</emphasis>! You should have
locked your security down like the installation
instructions told you to. You can find details on
locking down your database in the Bugzilla FAQ in this
directory (under "Security"), or more robust security
generalities in the MySQL searchable documentation at
http://www.mysql.com/php/manual.php3?section=Privilege_system .
</para>
</listitem>
<listitem>
<para>You should now be at a prompt that looks like
this:</para>
<para><prompt>mysql></prompt></para>
<para>At the prompt, if <quote>bugs</quote> is the name
you chose in the<filename>localconfig</filename> file
for your Bugzilla database, type:</para>
<para><prompt>mysql</prompt><command>use bugs;</command></para>
<note>
<para>Don't forget the <quote>;</quote> at the end of
each line, or you'll be kicking yourself later.</para>
</note>
</listitem>
</orderedlist>
</para>
<section>
<title>Bugzilla Database Tables</title>
<para> Imagine your MySQL database as a series of
spreadsheets, and you won't be too far off. If you use this
command:</para>
<para><prompt>mysql></prompt><command>show tables from bugs;</command></para>
<para>you'll be able to see all the
<quote>spreadsheets</quote> (tables) in your database. It
is similar to a file system, only faster and more robust for
certain types of operations.</para>
<para>From the command issued above, ou should have some
output that looks like this:
<programlisting>
+-------------------+
| Tables in bugs |
+-------------------+
| attachments |
| bugs |
| bugs_activity |
| cc |
| components |
| dependencies |
| fielddefs |
| groups |
| keyworddefs |
| keywords |
| logincookies |
| longdescs |
| milestones |
| namedqueries |
| products |
| profiles |
| profiles_activity |
| shadowlog |
| tokens |
| versions |
| votes |
| watch |
+-------------------+
</programlisting></para>
<literallayout>
Here's an overview of what each table does. Most columns in each table have
descriptive names that make it fairly trivial to figure out their jobs.
attachments: This table stores all attachments to bugs. It tends to be your
largest table, yet also generally has the fewest entries because file
attachments are so (relatively) large.
bugs: This is the core of your system. The bugs table stores most of the
current information about a bug, with the exception of the info stored in the
other tables.
bugs_activity: This stores information regarding what changes are made to bugs
when -- a history file.
cc: This tiny table simply stores all the CC information for any bug which has
any entries in the CC field of the bug. Note that, like most other tables in
Bugzilla, it does not refer to users by their user names, but by their unique
userid, stored as a primary key in the profiles table.
components: This stores the programs and components (or products and
components, in newer Bugzilla parlance) for Bugzilla. Curiously, the "program"
(product) field is the full name of the product, rather than some other unique
identifier, like bug_id and user_id are elsewhere in the database.
dependencies: Stores data about those cool dependency trees.
fielddefs: A nifty table that defines other tables. For instance, when you
submit a form that changes the value of "AssignedTo" this table allows
translation to the actual field name "assigned_to" for entry into MySQL.
groups: defines bitmasks for groups. A bitmask is a number that can uniquely
identify group memberships. For instance, say the group that is allowed to
tweak parameters is assigned a value of "1", the group that is allowed to edit
users is assigned a "2", and the group that is allowed to create new groups is
assigned the bitmask of "4". By uniquely combining the group bitmasks (much
like the chmod command in UNIX,) you can identify a user is allowed to tweak
parameters and create groups, but not edit users, by giving him a bitmask of
"5", or a user allowed to edit users and create groups, but not tweak
parameters, by giving him a bitmask of "6" Simple, huh?
If this makes no sense to you, try this at the mysql prompt:
mysql> select * from groups;
You'll see the list, it makes much more sense that way.
keyworddefs: Definitions of keywords to be used
keywords: Unlike what you'd think, this table holds which keywords are
associated with which bug id's.
logincookies: This stores every login cookie ever assigned to you for every
machine you've ever logged into Bugzilla from. Curiously, it never does any
housecleaning -- I see cookies in this file I've not used for months. However,
since Bugzilla never expires your cookie (for convenience' sake), it makes
sense.
longdescs: The meat of bugzilla -- here is where all user comments are stored!
You've only got 2^24 bytes per comment (it's a mediumtext field), so speak
sparingly -- that's only the amount of space the Old Testament from the Bible
would take (uncompressed, 16 megabytes). Each comment is keyed to the
bug_id to which it's attached, so the order is necessarily chronological, for
comments are played back in the order in which they are received.
milestones: Interesting that milestones are associated with a specific product
in this table, but Bugzilla does not yet support differing milestones by
product through the standard configuration interfaces.
namedqueries: This is where everybody stores their "custom queries". Very
cool feature; it beats the tar out of having to bookmark each cool query you
construct.
products: What products you have, whether new bug entries are allowed for the
product, what milestone you're working toward on that product, votes, etc. It
will be nice when the components table supports these same features, so you
could close a particular component for bug entry without having to close an
entire product...
profiles: Ahh, so you were wondering where your precious user information was
stored? Here it is! With the passwords in plain text for all to see! (but
sshh... don't tell your users!)
profiles_activity: Need to know who did what when to who's profile? This'll
tell you, it's a pretty complete history.
shadowlog: I could be mistaken here, but I believe this table tells you when
your shadow database is updated and what commands were used to update it. We
don't use a shadow database at our site yet, so it's pretty empty for us.
versions: Version information for every product
<para>If you were like me, at this point you're totally clueless about
the internals of MySQL, and if it weren't for this executive order from
the Vice President you couldn't care less about the difference between
a
<quote>bigint</quote>
votes: Who voted for what when
and a
<quote>tinyint</quote>
watch: Who (according to userid) is watching who's bugs (according to their
userid).
entry in MySQL. I recommend you refer to the MySQL documentation,
available at
<ulink url="http://www.mysql.com/doc.html">MySQL.com</ulink>
. Below are the basics you need to know about the Bugzilla database.
Check the chart above for more details.</para>
===
THE DETAILS
===
Ahh, so you're wondering just what to do with the information above? At the
mysql prompt, you can view any information about the columns in a table with
this command (where "table" is the name of the table you wish to view):
mysql> show columns from table;
You can also view all the data in a table with this command:
mysql> select * from table;
<para>
<orderedlist>
<listitem>
<para>To connect to your database:</para>
-- note: this is a very bad idea to do on, for instance, the "bugs" table if
you have 50,000 bugs. You'll be sitting there a while until you ctrl-c or
50,000 bugs play across your screen.
<para>
<prompt>bash#</prompt>
You can limit the display from above a little with the command, where
"column" is the name of the column for which you wish to restrict information:
<command>mysql</command>
mysql> select * from table where (column = "some info");
<parameter>-u root</parameter>
</para>
-- or the reverse of this
<para>If this works without asking you for a password,
<emphasis>shame on you</emphasis>
mysql> select * from table where (column != "some info");
! You should have locked your security down like the installation
instructions told you to. You can find details on locking down
your database in the Bugzilla FAQ in this directory (under
"Security"), or more robust security generalities in the MySQL
searchable documentation at
http://www.mysql.com/php/manual.php3?section=Privilege_system
.</para>
</listitem>
Let's take our example from the introduction, and assume you need to change
the word "verified" to "approved" in the resolution field. We know from the
above information that the resolution is likely to be stored in the "bugs"
table. Note we'll need to change a little perl code as well as this database
change, but I won't plunge into that in this document. Let's verify the
information is stored in the "bugs" table:
<listitem>
<para>You should now be at a prompt that looks like this:</para>
mysql> show columns from bugs
<para>
<prompt>mysql&gt;</prompt>
</para>
(exceedingly long output truncated here)
| bug_status| enum('UNCONFIRMED','NEW','ASSIGNED','REOPENED','RESOLVED','VERIFIED','CLOSED')||MUL | UNCONFIRMED||
<para>At the prompt, if
<quote>bugs</quote>
Sorry about that long line. We see from this that the "bug status" column is
an "enum field", which is a MySQL peculiarity where a string type field can
only have certain types of entries. While I think this is very cool, it's not
standard SQL. Anyway, we need to add the possible enum field entry
'APPROVED' by altering the "bugs" table.
is the name you chose in the
<filename>localconfig</filename>
mysql> ALTER table bugs CHANGE bug_status bug_status
-> enum("UNCONFIRMED", "NEW", "ASSIGNED", "REOPENED", "RESOLVED",
-> "VERIFIED", "APPROVED", "CLOSED") not null;
file for your Bugzilla database, type:</para>
(note we can take three lines or more -- whatever you put in before the
semicolon is evaluated as a single expression)
<para>
<prompt>mysql</prompt>
Now if you do this:
<command>use bugs;</command>
</para>
mysql> show columns from bugs;
<note>
<para>Don't forget the
<quote>;</quote>
you'll see that the bug_status field has an extra "APPROVED" enum that's
available! Cool thing, too, is that this is reflected on your query page as
well -- you can query by the new status. But how's it fit into the existing
scheme of things?
Looks like you need to go back and look for instances of the word "verified"
in the perl code for Bugzilla -- wherever you find "verified", change it to
"approved" and you're in business (make sure that's a case-insensitive search).
Although you can query by the enum field, you can't give something a status
of "APPROVED" until you make the perl changes. Note that this change I
mentioned can also be done by editing checksetup.pl, which automates a lot of
this. But you need to know this stuff anyway, right?
at the end of each line, or you'll be kicking yourself
later.</para>
</note>
</listitem>
</orderedlist>
</para>
I hope this database tutorial has been useful for you. If you have comments
to add, questions, concerns, etc. please direct them to
mbarnson@excitehome.net. Please direct flames to /dev/null :) Have a nice
day!
<section>
<title>Bugzilla Database Tables</title>
<para>Imagine your MySQL database as a series of spreadsheets, and
you won't be too far off. If you use this command:</para>
<para>
<prompt>mysql&gt;</prompt>
===
LINKS
===
<command>show tables from bugs;</command>
</para>
Great MySQL tutorial site:
http://www.devshed.com/Server_Side/MySQL/
<para>you'll be able to see all the
<quote>spreadsheets</quote>
(tables) in your database. It is similar to a file system, only
faster and more robust for certain types of operations.</para>
<para>From the command issued above, ou should have some output that
looks like this:
<programlisting>+-------------------+ | Tables in bugs |
+-------------------+ | attachments | | bugs | | bugs_activity | | cc
| | components | | dependencies | | fielddefs | | groups | |
keyworddefs | | keywords | | logincookies | | longdescs | |
milestones | | namedqueries | | products | | profiles | |
profiles_activity | | shadowlog | | tokens | | versions | | votes | |
watch | +-------------------+</programlisting>
</para>
</literallayout>
<literallayout>Here's an overview of what each table does. Most
columns in each table have descriptive names that make it fairly
trivial to figure out their jobs. attachments: This table stores all
attachments to bugs. It tends to be your largest table, yet also
generally has the fewest entries because file attachments are so
(relatively) large. bugs: This is the core of your system. The bugs
table stores most of the current information about a bug, with the
exception of the info stored in the other tables. bugs_activity: This
stores information regarding what changes are made to bugs when -- a
history file. cc: This tiny table simply stores all the CC
information for any bug which has any entries in the CC field of the
bug. Note that, like most other tables in Bugzilla, it does not refer
to users by their user names, but by their unique userid, stored as a
primary key in the profiles table. components: This stores the
programs and components (or products and components, in newer
Bugzilla parlance) for Bugzilla. Curiously, the "program" (product)
field is the full name of the product, rather than some other unique
identifier, like bug_id and user_id are elsewhere in the database.
dependencies: Stores data about those cool dependency trees.
fielddefs: A nifty table that defines other tables. For instance,
when you submit a form that changes the value of "AssignedTo" this
table allows translation to the actual field name "assigned_to" for
entry into MySQL. groups: defines bitmasks for groups. A bitmask is a
number that can uniquely identify group memberships. For instance,
say the group that is allowed to tweak parameters is assigned a value
of "1", the group that is allowed to edit users is assigned a "2",
and the group that is allowed to create new groups is assigned the
bitmask of "4". By uniquely combining the group bitmasks (much like
the chmod command in UNIX,) you can identify a user is allowed to
tweak parameters and create groups, but not edit users, by giving him
a bitmask of "5", or a user allowed to edit users and create groups,
but not tweak parameters, by giving him a bitmask of "6" Simple, huh?
If this makes no sense to you, try this at the mysql prompt:
mysql&gt; select * from groups; You'll see the list, it makes much
more sense that way. keyworddefs: Definitions of keywords to be used
keywords: Unlike what you'd think, this table holds which keywords
are associated with which bug id's. logincookies: This stores every
login cookie ever assigned to you for every machine you've ever
logged into Bugzilla from. Curiously, it never does any housecleaning
-- I see cookies in this file I've not used for months. However,
since Bugzilla never expires your cookie (for convenience' sake), it
makes sense. longdescs: The meat of bugzilla -- here is where all
user comments are stored! You've only got 2^24 bytes per comment
(it's a mediumtext field), so speak sparingly -- that's only the
amount of space the Old Testament from the Bible would take
(uncompressed, 16 megabytes). Each comment is keyed to the bug_id to
which it's attached, so the order is necessarily chronological, for
comments are played back in the order in which they are received.
milestones: Interesting that milestones are associated with a
specific product in this table, but Bugzilla does not yet support
differing milestones by product through the standard configuration
interfaces. namedqueries: This is where everybody stores their
"custom queries". Very cool feature; it beats the tar out of having
to bookmark each cool query you construct. products: What products
you have, whether new bug entries are allowed for the product, what
milestone you're working toward on that product, votes, etc. It will
be nice when the components table supports these same features, so
you could close a particular component for bug entry without having
to close an entire product... profiles: Ahh, so you were wondering
where your precious user information was stored? Here it is! With the
passwords in plain text for all to see! (but sshh... don't tell your
users!) profiles_activity: Need to know who did what when to who's
profile? This'll tell you, it's a pretty complete history. shadowlog:
I could be mistaken here, but I believe this table tells you when
your shadow database is updated and what commands were used to update
it. We don't use a shadow database at our site yet, so it's pretty
empty for us. versions: Version information for every product votes:
Who voted for what when watch: Who (according to userid) is watching
who's bugs (according to their userid). === THE DETAILS === Ahh, so
you're wondering just what to do with the information above? At the
mysql prompt, you can view any information about the columns in a
table with this command (where "table" is the name of the table you
wish to view): mysql&gt; show columns from table; You can also view
all the data in a table with this command: mysql&gt; select * from
table; -- note: this is a very bad idea to do on, for instance, the
"bugs" table if you have 50,000 bugs. You'll be sitting there a while
until you ctrl-c or 50,000 bugs play across your screen. You can
limit the display from above a little with the command, where
"column" is the name of the column for which you wish to restrict
information: mysql&gt; select * from table where (column = "some
info"); -- or the reverse of this mysql&gt; select * from table where
(column != "some info"); Let's take our example from the
introduction, and assume you need to change the word "verified" to
"approved" in the resolution field. We know from the above
information that the resolution is likely to be stored in the "bugs"
table. Note we'll need to change a little perl code as well as this
database change, but I won't plunge into that in this document. Let's
verify the information is stored in the "bugs" table: mysql&gt; show
columns from bugs (exceedingly long output truncated here) |
bug_status|
enum('UNCONFIRMED','NEW','ASSIGNED','REOPENED','RESOLVED','VERIFIED','CLOSED')||MUL
| UNCONFIRMED|| Sorry about that long line. We see from this that the
"bug status" column is an "enum field", which is a MySQL peculiarity
where a string type field can only have certain types of entries.
While I think this is very cool, it's not standard SQL. Anyway, we
need to add the possible enum field entry 'APPROVED' by altering the
"bugs" table. mysql&gt; ALTER table bugs CHANGE bug_status bug_status
-&gt; enum("UNCONFIRMED", "NEW", "ASSIGNED", "REOPENED", "RESOLVED",
-&gt; "VERIFIED", "APPROVED", "CLOSED") not null; (note we can take
three lines or more -- whatever you put in before the semicolon is
evaluated as a single expression) Now if you do this: mysql&gt; show
columns from bugs; you'll see that the bug_status field has an extra
"APPROVED" enum that's available! Cool thing, too, is that this is
reflected on your query page as well -- you can query by the new
status. But how's it fit into the existing scheme of things? Looks
like you need to go back and look for instances of the word
"verified" in the perl code for Bugzilla -- wherever you find
"verified", change it to "approved" and you're in business (make sure
that's a case-insensitive search). Although you can query by the enum
field, you can't give something a status of "APPROVED" until you make
the perl changes. Note that this change I mentioned can also be done
by editing checksetup.pl, which automates a lot of this. But you need
to know this stuff anyway, right? I hope this database tutorial has
been useful for you. If you have comments to add, questions,
concerns, etc. please direct them to mbarnson@excitehome.net. Please
direct flames to /dev/null :) Have a nice day! === LINKS === Great
MySQL tutorial site:
http://www.devshed.com/Server_Side/MySQL/</literallayout>
</section>
</section>
</section>
......@@ -362,192 +316,126 @@ http://www.devshed.com/Server_Side/MySQL/
<title>MySQL Permissions &amp; Grant Tables</title>
<note>
<para>The following portion of documentation comes from my
answer to an old discussion of Keystone, a cool product that
does trouble-ticket tracking for IT departments. I wrote this
post to the Keystone support group regarding MySQL grant
table permissions, and how to use them effectively. It is
badly in need of updating, as I believe MySQL has added a
field or two to the grant tables since this time, but it
serves as a decent introduction and troubleshooting document
for grant table issues. I used Keynote to track my troubles
until I discovered Bugzilla, which gave me a whole new set of
troubles to work on : ) Although it is of limited use, it
still has SOME use, thus it's still included.</para>
<para>
Please note, however, that I was a relatively new user to
MySQL at the time. Some of my suggestions, particularly in
how to set up security, showed a terrible lack of
security-related database experience.
</para>
<para>The following portion of documentation comes from my answer to an
old discussion of Keystone, a cool product that does trouble-ticket
tracking for IT departments. I wrote this post to the Keystone support
group regarding MySQL grant table permissions, and how to use them
effectively. It is badly in need of updating, as I believe MySQL has
added a field or two to the grant tables since this time, but it serves
as a decent introduction and troubleshooting document for grant table
issues. I used Keynote to track my troubles until I discovered
Bugzilla, which gave me a whole new set of troubles to work on : )
Although it is of limited use, it still has SOME use, thus it's still
included.</para>
<para>Please note, however, that I was a relatively new user to MySQL
at the time. Some of my suggestions, particularly in how to set up
security, showed a terrible lack of security-related database
experience.</para>
</note>
<literallayout>
From matt_barnson@singletrac.com Wed Jul 7 09:00:07 1999
Date: Mon, 1 Mar 1999 21:37:04 -0700
From: Matthew Barnson matt_barnson@singletrac.com
To: keystone-users@homeport.org
Subject: [keystone-users] Grant Tables FAQ
[The following text is in the "iso-8859-1" character set]
[Your display is set for the "US-ASCII" character set]
[Some characters may be displayed incorrectly]
Maybe we can include this rambling message in the Keystone FAQ? It gets
asked a lot, and the only option current listed in the FAQ is
"--skip-grant-tables".
Really, you can't go wrong by reading section 6 of the MySQL manual, at
http://www.mysql.com/Manual/manual.html. I am sure their description is
better than mine.
MySQL runs fine without permissions set up correctly if you run the mysql
daemon with the "--skip-grant-tables" option. Running this way denies
access to nobody. Unfortunately, unless you've got yourself firewalled it
also opens the potential for abuse if someone knows you're running it.
Additionally, the default permissions for MySQL allow anyone at localhost
access to the database if the database name begins with "test_" or is named
"test" (i.e. "test_keystone"). You can change the name of your database in
the keystone.conf file ($sys_dbname). This is the way I am doing it for
some of my databases, and it works fine.
The methods described below assume you're running MySQL on the same box as
your webserver, and that you don't mind if your $sys_dbuser for Keystone has
superuser access. See near the bottom of this message for a description of
what each field does.
Method #1:
1. cd /var/lib
#location where you'll want to run /usr/bin/mysql_install_db shell
script from to get it to work.
2. ln -s mysql data
# soft links the "mysql" directory to "data", which is what
mysql_install_db expects. Alternately, you can edit mysql_install_db and
change all the "./data" references to "./mysql".
3. Edit /usr/bin/mysql_install_db with your favorite text editor (vi,
emacs, jot, pico, etc.)
A) Copy the "INSERT INTO db VALUES
('%','test\_%','','Y','Y','Y','Y','Y','Y');" and paste it immediately after
itself. Chage the 'test\_%' value to 'keystone', or the value of
$sys_dbname in keystone.conf.
B) If you are running your keystone database with any user, you'll need to
copy the "INSERT INTO user VALUES
('localhost','root','','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');" line after
itself and change 'root' to the name of the keystone database user
($sys_dbuser) in keystone.conf.
# adds entries to the script to create grant tables for specific
hosts and users. The user you set up has super-user access ($sys_dbuser) --
you may or may not want this. The layout of mysql_install_db is really very
uncomplicated.
4. /usr/bin/mysqladmin shutdown
# ya gotta shut it down before you can reinstall the grant tables!
5. rm -i /var/lib/mysql/mysql/*.IS?' and answer 'Y' to the deletion
questions.
# nuke your current grant tables. This WILL NOT delete any other
databases than your grant tables.
6. /usr/bin/mysql_install_db
# run the script you just edited to install your new grant tables.
7. mysqladmin -u root password (new_password)
# change the root MySQL password, or else anyone on localhost can
login to MySQL as root and make changes. You can skip this step if you want
keystone to connect as root with no password.
8. mysqladmin -u (webserver_user_name) password (new_password)
# change the password of the $sys_dbuser. Note that you will need
to change the password in the keystone.conf file as well in $sys_dbpasswd,
and if your permissions are set up incorrectly anybody can type the URL to
your keystone.conf file and get the password. Not that this will help them
much if your permissions are set to @localhost.
Method #2: easier, but a pain reproducing if you have to delete your grant
tables. This is the "recommended" method for altering grant tables in
MySQL. I don't use it because I like the other way :)
shell> mysql --user=root keystone
mysql> GRANT
SELECT,INSERT,UPDATE,DELETE,INDEX,ALTER,CREATE,DROP,RELOAD,SHUTDOWN,PROCESS,
FILE,
ON keystone.*
TO &lt;$sys_dbuser name>@localhost
IDENTIFIED BY '(password)'
WITH GRANT OPTION;
OR
mysql> GRANT ALL PRIVILEGES
ON keystone.*
TO &lt;$sys_dbuser name>@localhost
IDENTIFIED BY '(password)'
WITH GRANT OPTION;
# this grants the required permissions to the keystone ($sys_dbuser)
account defined in keystone.conf. However, if you are runnning many
different MySQL-based apps, as we are, it's generally better to edit the
mysql_install_db script to be able to quickly reproduce your permissions
structure again. Note that the FILE privelege and WITH GRANT OPTION may not
be in your best interest to include.
GRANT TABLE FIELDS EXPLANATION:
Quick syntax summary: "%" in MySQL is a wildcard. I.E., if you are
defining your DB table and in the 'host' field and enter '%', that means
that any host can access that database. Of course, that host must also have
a valid db user in order to do anything useful. 'db'=name of database. In
our case, it should be "keystone". "user" should be your "$sys_dbuser"
defined in keystone.conf. Note that you CANNOT add or change a password by
using the "INSERT INTO db (X)" command -- you must change it with the mysql
-u command as defined above. Passwords are stored encrypted in the MySQL
database, and if you try to enter it directly into the table they will not
match.
TABLE: USER. Everything after "password" is a privelege granted (Y/N).
This table controls individual user global access rights.
'host','user','password','select','insert','update','delete','index','alter'
,'create','drop','grant','reload','shutdown','process','file'
TABLE: DB. This controls access of USERS to databases.
'host','db','user','select','insert','update','delete','index','alter','crea
te','drop','grant'
TABLE: HOST. This controls which HOSTS are allowed what global access
rights. Note that the HOST table, USER table, and DB table are very closely
connected -- if an authorized USER attempts an SQL request from an
unauthorized HOST, she's denied. If a request from an authorized HOST is
not an authorized USER, it is denied. If a globally authorized USER does
not have rights to a certain DB, she's denied. Get the picture?
'host','db','select','insert','update','delete','index','alter','create','dr
op','grant'
You should now have a working knowledge of MySQL grant tables. If there is
anything I've left out of this answer that you feel is pertinent, or if my
instructions don't work for you, please let me know and I'll re-post this
letter again, corrected. I threw it together one night out of exasperation
for all the newbies who don't know squat about MySQL yet, so it is almost
guaranteed to have errors.
Once again, you can't go wrong by reading section 6 of the MySQL manual. It
is more detailed than I!
http://www.mysql.com/Manual/manual.html.
</literallayout>
<literallayout>From matt_barnson@singletrac.com Wed Jul 7 09:00:07 1999
Date: Mon, 1 Mar 1999 21:37:04 -0700 From: Matthew Barnson
matt_barnson@singletrac.com To: keystone-users@homeport.org Subject:
[keystone-users] Grant Tables FAQ [The following text is in the
"iso-8859-1" character set] [Your display is set for the "US-ASCII"
character set] [Some characters may be displayed incorrectly] Maybe we
can include this rambling message in the Keystone FAQ? It gets asked a
lot, and the only option current listed in the FAQ is
"--skip-grant-tables". Really, you can't go wrong by reading section 6 of
the MySQL manual, at http://www.mysql.com/Manual/manual.html. I am sure
their description is better than mine. MySQL runs fine without
permissions set up correctly if you run the mysql daemon with the
"--skip-grant-tables" option. Running this way denies access to nobody.
Unfortunately, unless you've got yourself firewalled it also opens the
potential for abuse if someone knows you're running it. Additionally, the
default permissions for MySQL allow anyone at localhost access to the
database if the database name begins with "test_" or is named "test"
(i.e. "test_keystone"). You can change the name of your database in the
keystone.conf file ($sys_dbname). This is the way I am doing it for some
of my databases, and it works fine. The methods described below assume
you're running MySQL on the same box as your webserver, and that you
don't mind if your $sys_dbuser for Keystone has superuser access. See
near the bottom of this message for a description of what each field
does. Method #1: 1. cd /var/lib #location where you'll want to run
/usr/bin/mysql_install_db shell script from to get it to work. 2. ln -s
mysql data # soft links the "mysql" directory to "data", which is what
mysql_install_db expects. Alternately, you can edit mysql_install_db and
change all the "./data" references to "./mysql". 3. Edit
/usr/bin/mysql_install_db with your favorite text editor (vi, emacs, jot,
pico, etc.) A) Copy the "INSERT INTO db VALUES
('%','test\_%','','Y','Y','Y','Y','Y','Y');" and paste it immediately
after itself. Chage the 'test\_%' value to 'keystone', or the value of
$sys_dbname in keystone.conf. B) If you are running your keystone
database with any user, you'll need to copy the "INSERT INTO user VALUES
('localhost','root','','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');" line
after itself and change 'root' to the name of the keystone database user
($sys_dbuser) in keystone.conf. # adds entries to the script to create
grant tables for specific hosts and users. The user you set up has
super-user access ($sys_dbuser) -- you may or may not want this. The
layout of mysql_install_db is really very uncomplicated. 4.
/usr/bin/mysqladmin shutdown # ya gotta shut it down before you can
reinstall the grant tables! 5. rm -i /var/lib/mysql/mysql/*.IS?' and
answer 'Y' to the deletion questions. # nuke your current grant tables.
This WILL NOT delete any other databases than your grant tables. 6.
/usr/bin/mysql_install_db # run the script you just edited to install
your new grant tables. 7. mysqladmin -u root password (new_password) #
change the root MySQL password, or else anyone on localhost can login to
MySQL as root and make changes. You can skip this step if you want
keystone to connect as root with no password. 8. mysqladmin -u
(webserver_user_name) password (new_password) # change the password of
the $sys_dbuser. Note that you will need to change the password in the
keystone.conf file as well in $sys_dbpasswd, and if your permissions are
set up incorrectly anybody can type the URL to your keystone.conf file
and get the password. Not that this will help them much if your
permissions are set to @localhost. Method #2: easier, but a pain
reproducing if you have to delete your grant tables. This is the
"recommended" method for altering grant tables in MySQL. I don't use it
because I like the other way :) shell&gt; mysql --user=root keystone
mysql&gt; GRANT
SELECT,INSERT,UPDATE,DELETE,INDEX,ALTER,CREATE,DROP,RELOAD,SHUTDOWN,PROCESS,
FILE, ON keystone.* TO &lt;$sys_dbuser name&gt;@localhost IDENTIFIED BY
'(password)' WITH GRANT OPTION; OR mysql&gt; GRANT ALL PRIVILEGES ON
keystone.* TO &lt;$sys_dbuser name&gt;@localhost IDENTIFIED BY
'(password)' WITH GRANT OPTION; # this grants the required permissions to
the keystone ($sys_dbuser) account defined in keystone.conf. However, if
you are runnning many different MySQL-based apps, as we are, it's
generally better to edit the mysql_install_db script to be able to
quickly reproduce your permissions structure again. Note that the FILE
privelege and WITH GRANT OPTION may not be in your best interest to
include. GRANT TABLE FIELDS EXPLANATION: Quick syntax summary: "%" in
MySQL is a wildcard. I.E., if you are defining your DB table and in the
'host' field and enter '%', that means that any host can access that
database. Of course, that host must also have a valid db user in order to
do anything useful. 'db'=name of database. In our case, it should be
"keystone". "user" should be your "$sys_dbuser" defined in keystone.conf.
Note that you CANNOT add or change a password by using the "INSERT INTO
db (X)" command -- you must change it with the mysql -u command as
defined above. Passwords are stored encrypted in the MySQL database, and
if you try to enter it directly into the table they will not match.
TABLE: USER. Everything after "password" is a privelege granted (Y/N).
This table controls individual user global access rights.
'host','user','password','select','insert','update','delete','index','alter'
,'create','drop','grant','reload','shutdown','process','file' TABLE: DB.
This controls access of USERS to databases.
'host','db','user','select','insert','update','delete','index','alter','crea
te','drop','grant' TABLE: HOST. This controls which HOSTS are allowed
what global access rights. Note that the HOST table, USER table, and DB
table are very closely connected -- if an authorized USER attempts an SQL
request from an unauthorized HOST, she's denied. If a request from an
authorized HOST is not an authorized USER, it is denied. If a globally
authorized USER does not have rights to a certain DB, she's denied. Get
the picture?
'host','db','select','insert','update','delete','index','alter','create','dr
op','grant' You should now have a working knowledge of MySQL grant
tables. If there is anything I've left out of this answer that you feel
is pertinent, or if my instructions don't work for you, please let me
know and I'll re-post this letter again, corrected. I threw it together
one night out of exasperation for all the newbies who don't know squat
about MySQL yet, so it is almost guaranteed to have errors. Once again,
you can't go wrong by reading section 6 of the MySQL manual. It is more
detailed than I! http://www.mysql.com/Manual/manual.html.</literallayout>
</section>
</appendix>
<!-- Keep this comment at the end of the file
......@@ -570,3 +458,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/dbschema.mysql
View file @ 74bcd6f1
# MySQL dump 7.1
#
# Host: localhost Database: bugs
#--------------------------------------------------------
# Server version 3.22.32
#
# Table structure for table 'attachments'
#
CREATE TABLE attachments (
attach_id mediumint(9) DEFAULT '0' NOT NULL auto_increment,
bug_id mediumint(9) DEFAULT '0' NOT NULL,
creation_ts timestamp(14),
description mediumtext NOT NULL,
mimetype mediumtext NOT NULL,
ispatch tinyint(4),
filename mediumtext NOT NULL,
thedata longblob NOT NULL,
submitter_id mediumint(9) DEFAULT '0' NOT NULL,
PRIMARY KEY (attach_id)
);
create index index_41 on attachments (bug_id);
create index index_42 on attachments (creation_ts);
#
# Table structure for table 'bugs'
#
CREATE TABLE bugs (
bug_id mediumint(9) DEFAULT '0' NOT NULL auto_increment,
groupset bigint(20) DEFAULT '0' NOT NULL,
assigned_to mediumint(9) DEFAULT '0' NOT NULL,
bug_file_loc text,
bug_severity enum DEFAULT 'blocker' NOT NULL,
bug_status enum DEFAULT 'UNCONFIRMED' NOT NULL,
creation_ts datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
delta_ts timestamp(14),
short_desc mediumtext,
op_sys enum DEFAULT 'All' NOT NULL,
priority enum DEFAULT 'P1' NOT NULL,
product varchar(64) DEFAULT '' NOT NULL,
rep_platform enum,
reporter mediumint(9) DEFAULT '0' NOT NULL,
version varchar(16) DEFAULT '' NOT NULL,
component varchar(50) DEFAULT '' NOT NULL,
resolution enum DEFAULT '' NOT NULL,
target_milestone varchar(20) DEFAULT '---' NOT NULL,
qa_contact mediumint(9) DEFAULT '0' NOT NULL,
status_whiteboard mediumtext NOT NULL,
votes mediumint(9) DEFAULT '0' NOT NULL,
keywords mediumtext NOT NULL,
lastdiffed datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
everconfirmed tinyint(4) DEFAULT '0' NOT NULL,
PRIMARY KEY (bug_id)
);
create index index_7 on bugs (assigned_to);
create index index_8 on bugs (creation_ts);
create index index_9 on bugs (delta_ts);
create index index_10 on bugs (bug_severity);
create index index_11 on bugs (bug_status);
create index index_12 on bugs (op_sys);
create index index_13 on bugs (priority);
create index index_14 on bugs (product);
create index index_15 on bugs (reporter);
create index index_16 on bugs (version);
create index index_17 on bugs (component);
create index index_18 on bugs (resolution);
create index index_19 on bugs (target_milestone);
create index index_20 on bugs (qa_contact);
create index index_21 on bugs (votes);
#
# Table structure for table 'bugs_activity'
#
CREATE TABLE bugs_activity (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
bug_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
fieldid mediumint(9) DEFAULT '0' NOT NULL,
oldvalue tinytext,
newvalue tinytext
);
create index index_43 on bugs_activity (bug_id);
create index index_44 on bugs_activity (bug_when);
create index index_45 on bugs_activity (fieldid);
#
# Table structure for table 'cc'
#
CREATE TABLE cc (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL
);
create index index_31 on cc (who);
create unique index index_32 on cc (bug_id,who);
#
# Table structure for table 'components'
#
CREATE TABLE components (
value tinytext,
program varchar(64),
initialowner tinytext NOT NULL,
initialqacontact tinytext NOT NULL,
description mediumtext NOT NULL
);
#
# Table structure for table 'dependencies'
#
CREATE TABLE dependencies (
blocked mediumint(9) DEFAULT '0' NOT NULL,
dependson mediumint(9) DEFAULT '0' NOT NULL
);
create index index_34 on dependencies (blocked);
create index index_35 on dependencies (dependson);
#
# Table structure for table 'duplicates'
#
CREATE TABLE duplicates (
dupe_of mediumint(9) DEFAULT '0' NOT NULL,
dupe mediumint(9) DEFAULT '0' NOT NULL,
PRIMARY KEY (dupe)
);
#
# Table structure for table 'fielddefs'
#
CREATE TABLE fielddefs (
fieldid mediumint(9) DEFAULT '0' NOT NULL auto_increment,
name varchar(64) DEFAULT '' NOT NULL,
description mediumtext NOT NULL,
mailhead tinyint(4) DEFAULT '0' NOT NULL,
sortkey smallint(6) DEFAULT '0' NOT NULL,
PRIMARY KEY (fieldid)
);
create unique index index_28 on fielddefs (name);
create index index_29 on fielddefs (sortkey);
#
# Table structure for table 'groups'
#
CREATE TABLE groups (
bit bigint(20) DEFAULT '0' NOT NULL,
name varchar(255) DEFAULT '' NOT NULL,
description text NOT NULL,
isbuggroup tinyint(4) DEFAULT '0' NOT NULL,
userregexp tinytext NOT NULL
);
create unique index index_3 on groups (bit);
create unique index index_4 on groups (name);
#
# Table structure for table 'keyworddefs'
#
CREATE TABLE keyworddefs (
id smallint(6) DEFAULT '0' NOT NULL,
name varchar(64) DEFAULT '' NOT NULL,
description mediumtext,
PRIMARY KEY (id)
);
create unique index index_33 on keyworddefs (name);
#
# Table structure for table 'keywords'
#
CREATE TABLE keywords (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
keywordid smallint(6) DEFAULT '0' NOT NULL
);
create index index_39 on keywords (keywordid);
create unique index index_40 on keywords (bug_id, keywordid);
#
# Table structure for table 'logincookies'
#
CREATE TABLE logincookies (
cookie mediumint(9) DEFAULT '0' NOT NULL auto_increment,
userid mediumint(9) DEFAULT '0' NOT NULL,
cryptpassword varchar(64),
hostname varchar(128),
lastused timestamp(14),
PRIMARY KEY (cookie)
);
create index index_30 on logincookies (lastused);
#
# Table structure for table 'longdescs'
#
CREATE TABLE longdescs (
bug_id mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
bug_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
thetext mediumtext
);
create index index_22 on longdescs (bug_id);
create index index_23 on longdescs (bug_when);
#
# Table structure for table 'milestones'
#
CREATE TABLE milestones (
value varchar(20) DEFAULT '' NOT NULL,
product varchar(64) DEFAULT '' NOT NULL,
sortkey smallint(6) DEFAULT '0' NOT NULL,
);
create unique index index_24 on milestones (product, value);
#
# Table structure for table 'namedqueries'
#
CREATE TABLE namedqueries (
userid mediumint(9) DEFAULT '0' NOT NULL,
name varchar(64) DEFAULT '' NOT NULL,
watchfordiffs tinyint(4) DEFAULT '0' NOT NULL,
linkinfooter tinyint(4) DEFAULT '0' NOT NULL,
query mediumtext NOT NULL
);
create unique index index_25 on namedqueries (userid, name);
create index index_26 on namedqueries (watchfordiffs);
#
# Table structure for table 'products'
#
CREATE TABLE products (
product varchar(64),
description mediumtext,
milestoneurl tinytext NOT NULL,
disallownew tinyint(4) DEFAULT '0' NOT NULL,
votesperuser smallint(6) DEFAULT '0' NOT NULL,
maxvotesperbug smallint(6) DEFAULT '10000' NOT NULL,
votestoconfirm smallint(6) DEFAULT '0' NOT NULL,
defaultmilestone varchar(20) DEFAULT '---' NOT NULL
);
#
# Table structure for table 'profiles'
#
CREATE TABLE profiles (
userid mediumint(9) DEFAULT '0' NOT NULL auto_increment,
login_name varchar(255) DEFAULT '' NOT NULL,
password varchar(16),
cryptpassword varchar(64),
realname varchar(255),
groupset bigint(20) DEFAULT '0' NOT NULL,
emailnotification enum DEFAULT 'ExcludeSelfChanges' NOT NULL,
disabledtext mediumtext NOT NULL,
newemailtech tinyint(4) DEFAULT '0' NOT NULL,
mybugslink tinyint(4) DEFAULT '1' NOT NULL,
blessgroupset bigint(20) DEFAULT '0' NOT NULL,
PRIMARY KEY (userid)
);
create unique index index_27 on profiles (login_name);
#
# Table structure for table 'profiles_activity'
#
CREATE TABLE profiles_activity (
userid mediumint(9) DEFAULT '0' NOT NULL,
who mediumint(9) DEFAULT '0' NOT NULL,
profiles_when datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
fieldid mediumint(9) DEFAULT '0' NOT NULL,
oldvalue tinytext,
newvalue tinytext
);
create index index_0 on profiles_activity (userid);
create index index_1 on profiles_activity (profiles_when);
create index index_2 on profiles_activity (fieldid);
#
# Table structure for table 'shadowlog'
#
CREATE TABLE shadowlog (
id int(11) DEFAULT '0' NOT NULL auto_increment,
ts timestamp(14),
reflected tinyint(4) DEFAULT '0' NOT NULL,
command mediumtext NOT NULL,
PRIMARY KEY (id)
);
create index index_38 on shadowlog (reflected);
#
# Table structure for table 'versions'
#
CREATE TABLE versions (
value tinytext,
program varchar(64) DEFAULT '' NOT NULL
);
#
# Table structure for table 'votes'
#
CREATE TABLE votes (
who mediumint(9) DEFAULT '0' NOT NULL,
bug_id mediumint(9) DEFAULT '0' NOT NULL,
count smallint(6) DEFAULT '0' NOT NULL
);
create index index_5 on votes (who);
create index index_6 on votes (bug_id);
#
# Table structure for table 'watch'
#
CREATE TABLE watch (
watcher mediumint(9) DEFAULT '0' NOT NULL,
watched mediumint(9) DEFAULT '0' NOT NULL
);
create index index_36 on watch (watched);
create unique index index_37 on watch (watcher, watched);
docs/xml/faq.xml
View file @ 74bcd6f1
......@@ -17,8 +17,8 @@
<answer>
<para>
You can stay up-to-date with the latest Bugzilla
information at <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink>
information at <ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink>
</para>
</answer>
</qandaentry>
......@@ -54,7 +54,7 @@
<para>
There are several experienced
Bugzilla hackers on the mailing list/newsgroup who are willing
to whore themselves out for generous compensation.
to make themselves available for generous compensation.
Try sending a message to the mailing list asking for a volunteer.
</para>
</answer>
......@@ -74,12 +74,11 @@
<simplelist>
<member>Netscape/AOL</member>
<member>Mozilla.org</member>
<member>NASA</member>
<member>AtHome Corporation</member>
<member>Red Hat Software</member>
<member>Loki Entertainment Software</member>
<member>SuSe Corp</member>
<member>The Horde Project</member>
<member>The Eazel Project</member>
<member>AbiSource</member>
<member>Real Time Enterprises, Inc</member>
<member>Eggheads.org</member>
......@@ -88,6 +87,7 @@
<member>Creative Labs (makers of SoundBlaster)</member>
<member>The Apache Foundation</member>
<member>The Gnome Foundation</member>
<member>Ximian</member>
<member>Linux-Mandrake</member>
</simplelist>
</para>
......@@ -106,9 +106,9 @@
</question>
<answer>
<para>
Bugzilla maintenance has been in a state of flux recently.
Please check <ulink
url="http://www.mozilla.org/projects/bugzilla/">the Bugzilla Project Page for the latest details. </ulink>
A
<ulink url="http://www.bugzilla.org/who_we_are.html">core team</ulink>,
led by Dave Miller (justdave@syndicomm.com).
</para>
</answer>
</qandaentry>
......@@ -144,13 +144,13 @@
<qandaentry>
<question>
<para>
How do I change my user name in Bugzilla?
How do I change my user name (email address) in Bugzilla?
</para>
</question>
<answer>
<para>
You can't. However, the administrative account can, by simply opening
your user account in editusers.cgi and changing the login name.
New in 2.16 - go to the Account section of the Preferences. You will
be emailed at both addresses for confirmation.
</para>
</answer>
</qandaentry>
......@@ -175,7 +175,7 @@
You can help the project along by either hacking a patch yourself
that supports the functionality you require, or else submitting a
"Request for Enhancement" (RFE) using the bug submission interface
at <ulink url="http://bugzilla.mozilla.org/">bugzilla.mozilla.org</ulink>.
at <ulink url="http://bugzilla.mozilla.org/enter_bug.cgi?product=Bugzilla">bugzilla.mozilla.org</ulink>.
</para>
</answer>
</qandaentry>
......@@ -188,42 +188,10 @@
</para>
</question>
<answer>
<para>Terry Weissman answers,
<blockquote>
<para>
You're not the only one. But <emphasis>I</emphasis> am not very interested. I'm not
a real SQL or database person. I just wanted to make a useful tool,
and build it on top of free software. So, I picked MySQL, and
learned SQL by staring at the MySQL manual and some code lying
around here, and
wrote Bugzilla. I didn't know that Enum's were non-standard SQL.
I'm not sure if I would have cared, but I didn't even know. So, to
me, things are "portable" because it uses MySQL, and MySQL is
portable enough. I fully understand (now) that people want to be
portable to other databases, but that's never been a real concern
of mine.
</para>
</blockquote>
</para>
<para>
Things aren't quite that grim these days, however. Terry pretty much
sums up much of the thinking many of us have for Bugzilla, but there
is light on the horizon for database-independence! Here are some options:
There is DB-independence work afoot. PostgreSQL support is planned
for 2.18, and full DB-independence can't be far further on.
</para>
<simplelist>
<member>
<emphasis><ulink url="http://bugzilla.redhat.com/">Red Hat Bugzilla</ulink></emphasis>:
Runs a modified Bugzilla 2.8 atop an Oracle database.
</member>
<member>
<emphasis><ulink url="http://sourceforge.net/projects/interzilla">Interzilla</ulink></emphasis>:
A project to run Bugzilla on Interbase. No code released yet, however.
</member>
<member>
<emphasis>Bugzilla 3.0</emphasis>: One of the primary stated goals
is multiple database support.
</member>
</simplelist>
</answer>
</qandaentry>
......@@ -257,10 +225,6 @@
of perl to /usr/bonsaitools/bin/perl. This will make upgrading
your Bugzilla much easier in the future.
</para>
<para>
Obviously, if you do not have root access to your Bugzilla
box, our suggestion is irrelevant.
</para>
</note>
</blockquote>
</para>
......@@ -269,252 +233,6 @@
</qandadiv>
<qandadiv id="faq-redhat">
<title>Red Hat Bugzilla</title>
<para>
<note>
<para>
<emphasis>This section is no longer up-to-date.</emphasis>
Please see the section on "Red Hat Bugzilla" under "Variants" in The Bugzilla Guide.
</para>
</note>
</para>
<qandaentry>
<question>
<para>
What about Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
Red Hat Bugzilla is arguably more user-friendly, customizable, and scalable
than stock Bugzilla. Check it out at
http://bugzilla.redhat.com and the sources at ftp://people.redhat.com/dkl/.
They've set their Bugzilla up to work with Oracle out of the box.
Note that Redhat Bugzilla is based upon the 2.8 Bugzilla tree;
Bugzilla has made some tremendous advances since the 2.8 release.
Why not download both Bugzillas to check out the differences for
yourself?
</para>
<para>
Dave Lawrence, the original Red Hat Bugzilla maintainer, mentions:
<blockquote>
<para>
Somebody needs to take the ball and run with it. I'm the only
maintainer and am very pressed for time.
</para>
</blockquote>
If you, or someone you know, has the time and expertise to do the integration
work so main-tree Bugzilla 2.12 and higher integrates the Red
Hat Bugzilla Oracle modifications, please donate your
time to supporting the Bugzilla project.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
What are the primary benefits of Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
<emphasis>Dave Lawrence</emphasis>:
<blockquote>
<para>
For the record, we are not using any template type implementation for
the cosmetic changes maded to Bugzilla. It is just alot of html changes
in the code itself. I admit I may have gotten a little carried away with it
but the corporate types asked for a more standardized interface to match up
with other projects relating to Red Hat web sites. A lot of other web based
internal tools I am working on also look like Bugzilla.
</para>
<para>
I do want to land the changes that I have made to Bugzilla but I may
have to back out a good deal and make a different version of Red Hat's
Bugzilla for checking in to CVS. Especially the cosmetic changes because it
seems they may not fit the general public. I will do that as soon as I can.
I also still do my regular QA responsibilities along with Bugzilla so time
is difficult sometimes to come by.
</para>
<para>
There are also a good deal of other changes that were requested by
management for things like support contracts and different permission
groups for making bugs private. Here is a short list of the major
changes that have been made:
</para>
<orderedlist>
<listitem>
<para>
No enum types. All old enum types are now separate smaller tables.
</para>
</listitem>
<listitem>
<para>
No bit wise operations. Not all databases support this so they were
changed to a more generic way of doing this task
</para>
</listitem>
<listitem>
<para>
Bug reports can only be altered by the reporter, assignee, or a
privileged bugzilla user. The rest of the world can see the bug but in
a non-changeable format (unless the bug has been marked private). They
can however add comments, add and remove themselves from the CC list
</para>
</listitem>
<listitem>
<para>
Different group scheme. Each group has an id number related to it.
There is a user_group table which contains userid to groupid mappings
to determine which groups each user belongs to. Additionally there is
a bug_group table that has bugid to groupid mappings to show which
groups can see a particular bug. If there are no entries for a bug in
this table then the bug is public.
</para>
</listitem>
<listitem>
<para>
Product groups. product_table created to only allow certain products to
be visible for certain groups in both bug entry and query. This was
particulary helpful for support contracts.
</para>
</listitem>
<listitem>
<para>
Of course many (too many) changes to Bugzilla code itself to allow use
with Oracle and still allow operation with Mysql if so desired.
Currently if you use Mysql it is set to use Mysql's old permission
scheme to keep breakage to a minimum. Hopefully one day this will
standardize on one style which may of course be something completely
different.
</para>
</listitem>
<listitem>
<para>
Uses Text::Template perl module for rendering of the dynamic HTML pages
such as enter_bug.cgi, query.cgi, bug_form.pl, and for the header and
footer parts of the page. This allows the html to be separate from the
perl code for customizing the look and feel of the page to one's
preference.
</para>
</listitem>
<listitem>
<para>
There are many other smaller changes. There is also a port to Oracle
that I have been working on as time permits but is not completely
finished but somewhat usable. I will merge it into our standard code
base when it becomes production quality. Unfortunately there will have
to be some conditionals in the code to make it work with other than
Oracle due to some differences between Oracle and Mysql.
</para>
</listitem>
</orderedlist>
<para>
Both the Mysql and Oracle versions of our current code base are
available from ftp://people.redhat.com/dkl. If Terry/Tara wants I can submit
patch files for all of the changes I have made and he can determine what is
suitable for addition to the main bugzilla cade base. But for me to commit
changes to the actual CVS I will need to back out alot of things that are
not suitable for the rest of the Bugzilla community. I am open to
suggestions.
</para>
</blockquote>
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
What's the current status of Red Hat Bugzilla?
</para>
</question>
<answer>
<para>
<note>
<para>
This information is somewhat dated; I last updated it
7 June 2000. Please see the "Variants" section of "The Bugzilla Guide"
for more up-to-date information regarding Red Hat Bugzilla.
</para>
</note>
<emphasis>Dave Lawrence</emphasis>:
<blockquote>
<para>
I suppose the current thread warrants an update on the status of
Oracle and bugzilla ;) We have now been running Bugzilla 2.8 on
Oracle for the last two days in our production environment. I
tried to do as much testing as possible with it before going live
which is some of the reason for the long delay. I did not get
enough feedback as I would have liked from internal developers to
help weed out any bugs still left so I said "Fine, i will take it
live and then I will get the feedback I want :)" So it is now
starting to stabilize and it running quite well after working
feverishly the last two days fixing problems as soon as they came
in from the outside world. The current branch in cvs is up2date if
anyone would like to grab it and try it out. The oracle _setup.pl
is broken right now due to some last minute changes but I will
update that soon. Therefore you would probably need to create the
database tables the old fashioned way using the supplied sql
creation scripts located in the ./oracle directory. We have heavy
optimizations in the database it self thanks to the in-house DBA
here at Red Hat so it is running quite fast. The database itself
is located on a dual PII450 with 1GB ram and 14 high voltage
differential raided scsi drives. The tables and indexes are
partitioned in 4 chuncks across the raided drive which is nice
because when ever you need to do a full table scan, it is actually
starting in 4 different locations on 4 different drives
simultaneously. And the indexes of course are on separate drives
from the data so that speeds things up tremendously. When I can
find the time I will document all that we have done to get this
thing going to help others that may need it.
</para>
<para>
As Matt has mentioned it is still using out-dated code and with a
little help I would like to bring everything up to date for
eventual incorporation with the main cvs tree. Due to other
duties I have with the company any help with this wiould be
appreciated. What we are using now is what I call a best first
effort. It definitely can be improved on and may even need
complete rewrites in a lot of areas. A lot of changes may have to
be made in the way Bugzilla does things currently to make this
transition to a more generic database interface. Fortunately when
making the Oracle changes I made sure I didn't do anything that I
would consider Oracle specific and could not be easily done with
other databases. Alot of the sql statements need to be broken up
into smaller utilities that themselves would need to make
decisions on what database they are using but the majority of the
code can be made database neutral.
</para>
</blockquote>
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-loki">
<title>Loki Bugzilla (AKA Fenris)</title>
<qandaentry>
<question>
<para>
What is Loki Bugzilla (Fenris)?
</para>
</question>
<answer>
<para>
Loki Games has a customized version of Bugzilla available at
<ulink url="http://fenris.lokigames.com/">http://fenris.lokigames.com</ulink>. There are some advantages to using Fenris, chief being separation of comments based upon user privacy level, data hiding, forced login for any data retrieval, and some additional fields. Loki has mainted their code, originally a fork from the Bugzilla 2.8 code base, and it is quite a bit different than stock Bugzilla at this point. I recommend you stick with official Bugzilla version &bz-ver; rather than using a fork, but it's up to you.
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-phb">
<title>Pointy-Haired-Boss Questions</title>
<para>
......@@ -596,12 +314,11 @@
</question>
<answer>
<para>
Yes. There are many specific MIME-types that are pre-defined by Bugzilla,
Yes - any sort of attachment is allowed, although administrators can
configure a maximum size.
There are many specific MIME-types that are pre-defined by Bugzilla,
but you may specify any arbitrary MIME-type you need when you
upload the file. Since all attachments are stored in the database,
however, I recommend storing large binary attachments elsewhere
in the web server's file system and providing a hyperlink
as a comment, or in the provided "URL" field in the bug report.
upload the file.
</para>
</answer>
</qandaentry>
......@@ -634,67 +351,12 @@
<question>
<para>
The index.html page doesn't show the footer. It's really annoying to have
to go to the querypage just to check my "my bugs" link. How do I get a footer
on static HTML pages?
to go to the querypage just to check my "my bugs" link.
</para>
</question>
<answer>
<para>
It's possible to get the footer on the static index page using
Server Side Includes (SSI). The trick to doing this is making
sure that your web server is set up to allow SSI and specifically,
the #exec directive. You should also rename <filename>index.html</filename>
to <filename>index.shtml</filename>.
<para>If you upgrade to 2.16, the index page has a footer.
</para>
<para>
After you've done all that, you can add the following line to
<filename>index.shtml</filename>:
<programlisting>
<![CDATA[
<!--#exec cmd="/usr/bin/perl -e &quot;require 'CGI.pl'; PutFooter();&quot;" -->
]]>
</programlisting>
</para>
<para><note>
<para>
This line will be replaced with the actual HTML for the footer
when the page is requested, so you should put this line where you
want the footer to appear.
</para>
</note></para>
<para>
Because this method depends on being able to use a #exec directive,
and most ISP's will not allow that, there is an alternative method.
You could have a small script (such as <filename>api.cgi</filename>)
that basically looks like:
<programlisting>
<![CDATA[
#!/usr/bonsaitools/bin/perl -w
require 'globals.pl';
if ($::FORM{sub} eq 'PutFooter') {
PutFooter();
} else {
die 'api.cgi was incorrectly called';
}
]]>
</programlisting>
and then put this line in <filename>index.shtml</filename>.
<programlisting>
<![CDATA[
<!--#include virtual="api.cgi?sub=PutFooter"-->
]]>
</programlisting>
</para>
<para> <note>
<para>
This still requires being able to use Server Side Includes, if
this simply will not work for you, see <ulink
url="http://bugzilla.mozilla.org/show_bug.cgi?id=80183">bug 80183</ulink>
for a third option.
</para>
</note></para>
</answer>
</qandaentry>
<qandaentry>
......@@ -718,9 +380,6 @@ if ($::FORM{sub} eq 'PutFooter') {
better accomplished through third-party utilities that can
interface with the database directly.
</para>
<para>
Advanced Reporting is a Bugzilla 3.X proposed feature.
</para>
</answer>
</qandaentry>
......@@ -733,8 +392,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Email notification is user-configurable. The bug id and Topic
of the bug report accompany each email notification, along with
Email notification is user-configurable. By default, the bug id and
Summary of the bug report accompany each email notification, along with
a list of the changes made.
</para>
</answer>
......@@ -839,10 +498,10 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Currently, no. Internationalization support for Perl did not
exist in a robust fashion until the recent release of version 5.6.0;
Bugzilla is, and likely will remain (until 3.X) completely
non-localized.
To a certain extent, yes. 2.16's templates mean that you can localise
the user-facing UI (and several projects are doing exactly that.) However,
error messages and the admin interface are currently not localisable.
This should be achieved by 2.18.
</para>
</answer>
</qandaentry>
......@@ -983,13 +642,8 @@ if ($::FORM{sub} eq 'PutFooter') {
<para>
Commercial Bug-tracking software typically costs somewhere upwards
of $20,000 or more for 5-10 floating licenses. Bugzilla consultation
is available from skilled members of the newsgroup.
</para>
<para>
As an example, as of this writing I typically charge
$115 for the first hour, and $89 each hour thereafter
for consulting work. It takes me three to five hours to make Bugzilla
happy on a Development installation of Linux-Mandrake.
is available from skilled members of the newsgroup. Simple questions
are answered there and then.
</para>
</answer>
</qandaentry>
......@@ -1042,9 +696,9 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Check <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink> for details.
Once you download it, untar it, read the Bugzilla Guide.
Check <ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink> for details.
Read the other parts of this Guide for installation instructions.
</para>
</answer>
</qandaentry>
......@@ -1058,7 +712,7 @@ if ($::FORM{sub} eq 'PutFooter') {
<answer>
<para>
Installation on Windows NT has its own section in
"The Bugzilla Guide".
this document.
</para>
</answer>
</qandaentry>
......@@ -1090,8 +744,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Run mysql like this: "mysqld --skip-grant-tables". Please remember <emphasis>this
makes mysql as secure as taping a $100 to the floor of a football stadium
Run MySQL like this: "mysqld --skip-grant-tables". Please remember <emphasis>this
makes MySQL as secure as taping a $100 to the floor of a football stadium
bathroom for safekeeping.</emphasis> Please read the Security section of the
Administration chapter of "The Bugzilla Guide" before proceeding.
</para>
......@@ -1106,8 +760,9 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
The Bugzilla code has not undergone a complete security audit.
It is recommended that you closely examine permissions on your Bugzilla
The Bugzilla code has undergone a reasonably complete security audit,
and user-facing CGIs run under Perl's taint mode. However,
it is recommended that you closely examine permissions on your Bugzilla
installation, and follow the recommended security guidelines found
in The Bugzilla Guide.
</para>
......@@ -1145,8 +800,8 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
With the email changes to 2.12, the user should be able to set
this in user email preferences.
The user should be able to set
this in user email preferences (uncheck all boxes.)
</para>
</answer>
</qandaentry>
......@@ -1160,7 +815,7 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Edit the param for the mail text. Replace "To:" with "X-Real-To:",
Edit the "changedmail" param. Replace "To:" with "X-Real-To:",
replace "Cc:" with "X-Real-CC:", and add a "To: (myemailaddress)".
</para>
</answer>
......@@ -1224,14 +879,15 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
Email takes FOREVER to reach me from bugzilla -- it's extremely slow.
Email takes FOREVER to reach me from Bugzilla -- it's extremely slow.
What gives?
</para>
</question>
<answer>
<para>
If you are using an alternate Mail Transport Agent (MTA other than
sendmail), make sure the options given in the "processmail" script for all
sendmail), make sure the options given in the "processmail" and other
scripts for all
instances of "sendmail" are correct for your MTA.
</para>
<para>
......@@ -1244,7 +900,7 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
How come email never reaches me from bugzilla changes?
How come email from Bugzilla changes never reaches me?
</para>
</question>
<answer>
......@@ -1274,36 +930,10 @@ if ($::FORM{sub} eq 'PutFooter') {
</question>
<answer>
<para>
Red Hat Bugzilla, mentioned above, works with Oracle. The current version
Red Hat Bugzilla works with Oracle. The current version
from Mozilla.org does not have this capability. Unfortunately, though
you will sacrifice a lot of the really great features available in
Bugzilla 2.10 and 2.12 if you go with the 2.8-based Redhat version.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
Bugs are missing from queries, but exist in the database (and I can pull
them up by specifying the bug ID). What's wrong?
</para>
</question>
<answer>
<para>
You've almost certainly enabled the "shadow database", but for some
reason it hasn't been updated for all your bugs. This is the database
against which queries are run, so that really complex or slow queries won't
lock up portions of the database for other users. You can turn off the
shadow database in editparams.cgi. If you wish to continue using the shadow
database, then as your "bugs" user run "./syncshadowdb -syncall" from the
command line in the bugzilla installation directory to recreate your shadow
database. After it finishes, be sure to check the params and make sure that
"queryagainstshadowdb" is still turned on. The syncshadowdb program turns it
off if it was on, and is supposed to turn it back on when completed; that
way, if it crashes in the middle of recreating the database, it will stay
off forever until someone turns it back on by hand. Apparently, it doesn't
always do that yet.
Bugzilla 2.14 and 2.16 if you go with the 2.8-based Redhat version.
</para>
</answer>
</qandaentry>
......@@ -1413,42 +1043,6 @@ if ($::FORM{sub} eq 'PutFooter') {
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
Why do I get bizarre errors when trying to submit data, particularly problems
with "groupset"?
</para>
</question>
<answer>
<para>
If you're sure your MySQL parameters are correct, you might want turn
"strictvaluechecks" OFF in editparams.cgi. If you have "usebugsentry" set
"On", you also cannot submit a bug as readable by more than one group with
"strictvaluechecks" ON.
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
How come even after I delete bugs, the long descriptions show up?
</para>
</question>
<answer>
<para>
This should only happen with Bugzilla &bz-ver; if you are
using the <quote>shadow database</quote> feature, and your
shadow database is out of sync. Try running
<filename>syncshadowdb</filename>
<option>-syncall</option> to make sure your shadow
database is in synch with your primary database.
</para>
</answer>
</qandaentry>
</qandadiv>
<qandadiv id="faq-nt">
......@@ -1518,106 +1112,6 @@ if ($::FORM{sub} eq 'PutFooter') {
<qandaentry>
<question>
<para>
Can I have some general instructions on how to make Bugzilla on Win32 work?
</para>
</question>
<answer>
<para>
The following couple entries are deprecated in favor of the Windows installation
instructions available in the "Administration" portion of "The Bugzilla Guide".
However, they are provided here for historical interest and insight.
<literallayout>
1. #!C:/perl/bin/perl had to be added to every perl file.
2. Converted to Net::SMTP to handle mail messages instead of
/usr/bin/sendmail.
3. The crypt function isn't available on Windows NT (at least none that I
am aware), so I made encrypted passwords = plaintext passwords.
4. The system call to diff had to be changed to the Cygwin diff.
5. This was just to get a demo running under NT, it seems to be working
good, and I have inserted almost 100 bugs from another bug tracking
system. Since this work was done just to get an in-house demo, I am NOT
planning on making a patch for submission to Bugzilla. If you would
like a zip file, let me know.
Q: Hmm, couldn't figure it out from the general instructions above. How
about step-by-step?
A: Sure! Here ya go!
1. Install IIS 4.0 from the NT Option Pack #4.
2. Download and install Active Perl.
3. Install the Windows GNU tools from Cygwin. Make sure to add the bin
directory to your system path. (Everyone should have these, whether
they decide to use Bugzilla or not. :-) )
4. Download relevant packages from ActiveState at
http://www.activestate.com/packages/zips/. + DBD-Mysql.zip
5. Extract each zip file with WinZip, and install each ppd file using the
notation: ppm install &lt;module&gt;.ppd
6. Install Mysql. *Note: If you move the default install from c:\mysql,
you must add the appropriate startup parameters to the NT service. (ex.
-b e:\\programs\\mysql)
7. Download any Mysql client. http://www.mysql.com/download_win.html
8. Setup MySql. (These are the commands that I used.)
I. Cleanup default database settings.
C:\mysql\bin\mysql -u root mysql
mysql> DELETE FROM user WHERE Host='localhost' AND User='';
mysql> quit
C:\mysql\bin\mysqladmin reload
II. Set password for root.
C:\mysql\bin\mysql -u root mysql
mysql> UPDATE user SET Password=PASSWORD('new_password')
WHERE user='root';
mysql> FLUSH PRIVILEGES;
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
III. Create bugs user.
C:\mysql\bin\mysql -u root -p
mysql> insert into user (host,user,password)
values('localhost','bugs','');
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
IV. Create the bugs database.
C:\mysql\bin\mysql -u root -p
mysql> create database bugs;
V. Give the bugs user access to the bugs database.
mysql> insert into db
(host,db,user,select_priv,insert_priv,update_priv,delete_priv,create_priv,drop_priv)
values('localhost','bugs','bugs','Y','Y','Y','Y','Y','N')
mysql> quit
C:\mysql\bin\mysqladmin -u root reload
9. Run the table scripts to setup the bugs database.
10. Change CGI.pm to use the following regular expression because of
differing backslashes in NT versus UNIX.
o $0 =~ m:[^\\]*$:;
11. Had to make the crypt password = plain text password in the database.
(Thanks to Andrew Lahser" &lt;andrew_lahser@merck.com&gt;" on this one.) The
files that I changed were:
o globals.pl
o CGI.pl
o alternately, you can try commenting all references to 'crypt'
string and replace them with similar lines but without encrypt()
or crypr() functions insida all files.
12. Replaced sendmail with Windmail. Basically, you have to come up with a
sendmail substitute for NT. Someone said that they used a Perl module
(Net::SMTP), but I was trying to save time and do as little Perl coding
as possible.
13. Added "perl" to the beginning of all Perl system calls that use a perl
script as an argument and renamed processmail to processmail.pl.
14. In processmail.pl, I added binmode(HANDLE) before all read() calls. I'm
not sure about this one, but the read() under NT wasn't counting the
EOLs without the binary read."
</literallayout>
</para>
</answer>
</qandaentry>
<qandaentry>
<question>
<para>
I'm having trouble with the perl modules for NT not being able to talk to
to the database.
</para>
......@@ -1673,10 +1167,9 @@ A: Sure! Here ya go!
</question>
<answer>
<para>
We are developing in that direction. You can follow progress on this
at <ulink url="http://bugzilla.mozilla.org/show_bug.cgi?id=16775">
http://bugzilla.mozilla.org/show_bug.cgi?id=16775</ulink>. Some functionality
is available in Bugzilla 2.12, and is available as "quicksearch.html"
The interface was simplified by a UI designer for 2.16. Further
suggestions for improvement are welcome, but we won't sacrifice power for
simplicity.
</para>
</answer>
</qandaentry>
......@@ -1770,9 +1263,9 @@ A: Sure! Here ya go!
enhancement for Bugzilla.
</para>
<para>
You can view bugs marked for 2.16 release
<ulink url="http://bugzilla.mozilla.org/buglist.cgi?product=Bugzilla&amp;target_milestone=Bugzilla+2.16">here</ulink>.
This list includes bugs for the 2.16 release that have already
You can view bugs marked for 2.18 release
<ulink url="http://bugzilla.mozilla.org/buglist.cgi?product=Bugzilla&amp;target_milestone=Bugzilla+2.18">here</ulink>.
This list includes bugs for the 2.18 release that have already
been fixed and checked into CVS. Please consult the
<ulink url="http://www.mozilla.org/projects/bugzilla/">
Bugzilla Project Page</ulink> for details on how to
......@@ -1796,7 +1289,7 @@ A: Sure! Here ya go!
as adding the "---" priority field to your localconfig file in the appropriate area,
re-running checksetup.pl, and then changing the default priority in your browser using
"editparams.cgi". Hmm, now that I think about it, that is kind of a klunky way to handle
it, but for now it's what we have! Although the bug has been closed "resolved wontfix",
it, but for now it's what we have! Although the bug has been closed "RESOLVED WONTFIX",
there may be a better way to handle this...
</para>
</answer>
......@@ -1820,13 +1313,13 @@ A: Sure! Here ya go!
</listitem>
<listitem>
<para>
Upload your patch as a unified DIFF (having used "diff -u" against
Upload your patch as a unified diff (having used "diff -u" against
the <emphasis>current sources</emphasis> checked out of CVS),
or new source file by clicking
"Create a new attachment" link on the bug page you've just created, and
include any descriptions of database changes you may make, into the bug
ID you submitted in step #1. Be sure and click the "Patch" radio
button to indicate the text you are sending is a patch!
ID you submitted in step #1. Be sure and click the "Patch" checkbox
to indicate the text you are sending is a patch!
</para>
</listitem>
<listitem>
......
docs/xml/gfdl.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="gfdl">
<title>GNU Free Documentation License</title>
<title>GNU Free Documentation License</title>
<!-- - GNU Project - Free Software Foundation (FSF) -->
<!-- LINK REV="made" HREF="mailto:webmasters@gnu.org" -->
<!-- sect1>
<!-- sect1>
<title>GNU Free Documentation License</title -->
<para>Version 1.1, March 2000</para>
<blockquote>
<para>Copyright (C) 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.</para>
<para>Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place,
Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and
distribute verbatim copies of this license document, but changing it is
not allowed.</para>
</blockquote>
<sect1 label="0" id="gfdl-0">
<title>PREAMBLE</title>
<para>The purpose of this License is to make a manual, textbook,
or other written document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or
noncommercially. Secondarily, this License preserves for the
author and publisher a way to get credit for their work, while not
being considered responsible for modifications made by
<para>The purpose of this License is to make a manual, textbook, or other
written document "free" in the sense of freedom: to assure everyone the
effective freedom to copy and redistribute it, with or without modifying
it, either commercially or noncommercially. Secondarily, this License
preserves for the author and publisher a way to get credit for their
work, while not being considered responsible for modifications made by
others.</para>
<para>This License is a kind of "copyleft", which means that
derivative works of the document must themselves be free in the
same sense. It complements the GNU General Public License, which
is a copyleft license designed for free software.</para>
<para>We have designed this License in order to use it for manuals
for free software, because free software needs free documentation:
a free program should come with manuals providing the same
freedoms that the software does. But this License is not limited
to software manuals; it can be used for any textual work,
regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works
whose purpose is instruction or reference.</para>
<para>This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft license
designed for free software.</para>
<para>We have designed this License in order to use it for manuals for
free software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does. But this License is not limited to software manuals; it
can be used for any textual work, regardless of subject matter or whether
it is published as a printed book. We recommend this License principally
for works whose purpose is instruction or reference.</para>
</sect1>
<sect1 label="1" id="gfdl-1">
<title>APPLICABILITY AND DEFINITIONS</title>
<para>This License applies to any manual or other work that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. The "Document",
below, refers to any such manual or work. Any member of the
public is a licensee, and is addressed as "you".</para>
<para>A "Modified Version" of the Document means any work
containing the Document or a portion of it, either copied
verbatim, or with modifications and/or translated into another
language.</para>
<para>A "Secondary Section" is a named appendix or a front-matter
section of the Document that deals exclusively with the
relationship of the publishers or authors of the Document to the
Document's overall subject (or to related matters) and contains
nothing that could fall directly within that overall subject.
(For example, if the Document is in part a textbook of
mathematics, a Secondary Section may not explain any mathematics.)
The relationship could be a matter of historical connection with
the subject or with related matters, or of legal, commercial,
philosophical, ethical or political position regarding
them.</para>
<para>The "Invariant Sections" are certain Secondary Sections
whose titles are designated, as being those of Invariant Sections,
in the notice that says that the Document is released under this
License.</para>
<para>The "Cover Texts" are certain short passages of text that
are listed, as Front-Cover Texts or Back-Cover Texts, in the
notice that says that the Document is released under this
License.</para>
<para>A "Transparent" copy of the Document means a
machine-readable copy, represented in a format whose specification
is available to the general public, whose contents can be viewed
and edited directly and straightforwardly with generic text
editors or (for images composed of pixels) generic paint programs
or (for drawings) some widely available drawing editor, and that
is suitable for input to text formatters or for automatic
translation to a variety of formats suitable for input to text
formatters. A copy made in an otherwise Transparent file format
whose markup has been designed to thwart or discourage subsequent
modification by readers is not Transparent. A copy that is not
"Transparent" is called "Opaque".</para>
<para>Examples of suitable formats for Transparent copies include
plain ASCII without markup, Texinfo input format, LaTeX input
format, SGML or XML using a publicly available DTD, and
standard-conforming simple HTML designed for human modification.
Opaque formats include PostScript, PDF, proprietary formats that
can be read and edited only by proprietary word processors, SGML
or XML for which the DTD and/or processing tools are not generally
available, and the machine-generated HTML produced by some word
<para>This License applies to any manual or other work that contains a
notice placed by the copyright holder saying it can be distributed under
the terms of this License. The "Document", below, refers to any such
manual or work. Any member of the public is a licensee, and is addressed
as "you".</para>
<para>A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.</para>
<para>A "Secondary Section" is a named appendix or a front-matter section
of the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall subject
(or to related matters) and contains nothing that could fall directly
within that overall subject. (For example, if the Document is in part a
textbook of mathematics, a Secondary Section may not explain any
mathematics.) The relationship could be a matter of historical connection
with the subject or with related matters, or of legal, commercial,
philosophical, ethical or political position regarding them.</para>
<para>The "Invariant Sections" are certain Secondary Sections whose
titles are designated, as being those of Invariant Sections, in the
notice that says that the Document is released under this License.</para>
<para>The "Cover Texts" are certain short passages of text that are
listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says
that the Document is released under this License.</para>
<para>A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the general
public, whose contents can be viewed and edited directly and
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or for
automatic translation to a variety of formats suitable for input to text
formatters. A copy made in an otherwise Transparent file format whose
markup has been designed to thwart or discourage subsequent modification
by readers is not Transparent. A copy that is not "Transparent" is called
"Opaque".</para>
<para>Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML or
XML using a publicly available DTD, and standard-conforming simple HTML
designed for human modification. Opaque formats include PostScript, PDF,
proprietary formats that can be read and edited only by proprietary word
processors, SGML or XML for which the DTD and/or processing tools are not
generally available, and the machine-generated HTML produced by some word
processors for output purposes only.</para>
<para>The "Title Page" means, for a printed book, the title page
itself, plus such following pages as are needed to hold, legibly,
the material this License requires to appear in the title page.
For works in formats which do not have any title page as such,
"Title Page" means the text near the most prominent appearance of
the work's title, preceding the beginning of the body of the
text.</para>
<para>The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in formats
which do not have any title page as such, "Title Page" means the text
near the most prominent appearance of the work's title, preceding the
beginning of the body of the text.</para>
</sect1>
<sect1 label="2" id="gfdl-2">
<title>VERBATIM COPYING</title>
<para>You may copy and distribute the Document in any medium,
either commercially or noncommercially, provided that this
License, the copyright notices, and the license notice saying this
License applies to the Document are reproduced in all copies, and
that you add no other conditions whatsoever to those of this
License. You may not use technical measures to obstruct or
control the reading or further copying of the copies you make or
distribute. However, you may accept compensation in exchange for
copies. If you distribute a large enough number of copies you
must also follow the conditions in section 3.</para>
<para>You may also lend copies, under the same conditions stated
above, and you may publicly display copies.</para>
<para>You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies to
the Document are reproduced in all copies, and that you add no other
conditions whatsoever to those of this License. You may not use technical
measures to obstruct or control the reading or further copying of the
copies you make or distribute. However, you may accept compensation in
exchange for copies. If you distribute a large enough number of copies
you must also follow the conditions in section 3.</para>
<para>You may also lend copies, under the same conditions stated above,
and you may publicly display copies.</para>
</sect1>
<sect1 label="3" id="gfdl-3">
<title>COPYING IN QUANTITY</title>
<para>If you publish printed copies of the Document numbering more
than 100, and the Document's license notice requires Cover Texts,
you must enclose the copies in covers that carry, clearly and
legibly, all these Cover Texts: Front-Cover Texts on the front
cover, and Back-Cover Texts on the back cover. Both covers must
also clearly and legibly identify you as the publisher of these
copies. The front cover must present the full title with all
words of the title equally prominent and visible. You may add
other material on the covers in addition. Copying with changes
limited to the covers, as long as they preserve the title of the
Document and satisfy these conditions, can be treated as verbatim
copying in other respects.</para>
<para>If the required texts for either cover are too voluminous to
fit legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto
adjacent pages.</para>
<para>If you publish printed copies of the Document numbering more than
100, and the Document's license notice requires Cover Texts, you must
enclose the copies in covers that carry, clearly and legibly, all these
Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts
on the back cover. Both covers must also clearly and legibly identify you
as the publisher of these copies. The front cover must present the full
title with all words of the title equally prominent and visible. You may
add other material on the covers in addition. Copying with changes
limited to the covers, as long as they preserve the title of the Document
and satisfy these conditions, can be treated as verbatim copying in other
respects.</para>
<para>If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit reasonably)
on the actual cover, and continue the rest onto adjacent pages.</para>
<para>If you publish or distribute Opaque copies of the Document
numbering more than 100, you must either include a
machine-readable Transparent copy along with each Opaque copy, or
state in or with each Opaque copy a publicly-accessible
computer-network location containing a complete Transparent copy
of the Document, free of added material, which the general
network-using public has access to download anonymously at no
charge using public-standard network protocols. If you use the
latter option, you must take reasonably prudent steps, when you
begin distribution of Opaque copies in quantity, to ensure that
this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you
distribute an Opaque copy (directly or through your agents or
retailers) of that edition to the public.</para>
<para>It is requested, but not required, that you contact the
authors of the Document well before redistributing any large
number of copies, to give them a chance to provide you with an
updated version of the Document.</para>
numbering more than 100, you must either include a machine-readable
Transparent copy along with each Opaque copy, or state in or with each
Opaque copy a publicly-accessible computer-network location containing a
complete Transparent copy of the Document, free of added material, which
the general network-using public has access to download anonymously at no
charge using public-standard network protocols. If you use the latter
option, you must take reasonably prudent steps, when you begin
distribution of Opaque copies in quantity, to ensure that this
Transparent copy will remain thus accessible at the stated location until
at least one year after the last time you distribute an Opaque copy
(directly or through your agents or retailers) of that edition to the
public.</para>
<para>It is requested, but not required, that you contact the authors of
the Document well before redistributing any large number of copies, to
give them a chance to provide you with an updated version of the
Document.</para>
</sect1>
<sect1 label="4" id="gfdl-4">
<title>MODIFICATIONS</title>
<para>You may copy and distribute a Modified Version of the
Document under the conditions of sections 2 and 3 above, provided
that you release the Modified Version under precisely this
License, with the Modified Version filling the role of the
Document, thus licensing distribution and modification of the
Modified Version to whoever possesses a copy of it. In addition,
you must do these things in the Modified Version:</para>
<para>You may copy and distribute a Modified Version of the Document
under the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution and
modification of the Modified Version to whoever possesses a copy of it.
In addition, you must do these things in the Modified Version:</para>
<orderedlist numeration="upperalpha">
<listitem><para>Use in the Title Page
(and on the covers, if any) a title distinct from that of the
Document, and from those of previous versions (which should, if
there were any, be listed in the History section of the
Document). You may use the same title as a previous version if
the original publisher of that version gives permission.</para>
<listitem>
<para>Use in the Title Page (and on the covers, if any) a title
distinct from that of the Document, and from those of previous
versions (which should, if there were any, be listed in the History
section of the Document). You may use the same title as a previous
version if the original publisher of that version gives
permission.</para>
</listitem>
<listitem><para>List on the Title Page,
as authors, one or more persons or entities responsible for
authorship of the modifications in the Modified Version,
together with at least five of the principal authors of the
Document (all of its principal authors, if it has less than
five).</para>
<listitem>
<para>List on the Title Page, as authors, one or more persons or
entities responsible for authorship of the modifications in the
Modified Version, together with at least five of the principal
authors of the Document (all of its principal authors, if it has less
than five).</para>
</listitem>
<listitem><para>State on the Title page
the name of the publisher of the Modified Version, as the
publisher.</para>
<listitem>
<para>State on the Title page the name of the publisher of the
Modified Version, as the publisher.</para>
</listitem>
<listitem><para>Preserve all the
copyright notices of the Document.</para>
<listitem>
<para>Preserve all the copyright notices of the Document.</para>
</listitem>
<listitem><para>Add an appropriate
copyright notice for your modifications adjacent to the other
copyright notices.</para>
<listitem>
<para>Add an appropriate copyright notice for your modifications
adjacent to the other copyright notices.</para>
</listitem>
<listitem><para>Include, immediately
after the copyright notices, a license notice giving the public
permission to use the Modified Version under the terms of this
License, in the form shown in the Addendum below.</para>
<listitem>
<para>Include, immediately after the copyright notices, a license
notice giving the public permission to use the Modified Version under
the terms of this License, in the form shown in the Addendum
below.</para>
</listitem>
<listitem><para>Preserve in that license
notice the full lists of Invariant Sections and required Cover
Texts given in the Document's license notice.</para>
<listitem>
<para>Preserve in that license notice the full lists of Invariant
Sections and required Cover Texts given in the Document's license
notice.</para>
</listitem>
<listitem><para>Include an unaltered
copy of this License.</para>
<listitem>
<para>Include an unaltered copy of this License.</para>
</listitem>
<listitem><para>Preserve the section
entitled "History", and its title, and add to it an item stating
at least the title, year, new authors, and publisher of the
Modified Version as given on the Title Page. If there is no
section entitled "History" in the Document, create one stating
the title, year, authors, and publisher of the Document as given
on its Title Page, then add an item describing the Modified
<listitem>
<para>Preserve the section entitled "History", and its title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page. If
there is no section entitled "History" in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.</para>
</listitem>
<listitem><para>Preserve the network
location, if any, given in the Document for public access to a
Transparent copy of the Document, and likewise the network
locations given in the Document for previous versions it was
based on. These may be placed in the "History" section. You
may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.</para>
<listitem>
<para>Preserve the network location, if any, given in the Document
for public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions it
was based on. These may be placed in the "History" section. You may
omit a network location for a work that was published at least four
years before the Document itself, or if the original publisher of the
version it refers to gives permission.</para>
</listitem>
<listitem><para>In any section entitled
"Acknowledgements" or "Dedications", preserve the section's
title, and preserve in the section all the substance and tone of
each of the contributor acknowledgements and/or dedications
given therein.</para>
<listitem>
<para>In any section entitled "Acknowledgements" or "Dedications",
preserve the section's title, and preserve in the section all the
substance and tone of each of the contributor acknowledgements and/or
dedications given therein.</para>
</listitem>
<listitem><para>Preserve all the
Invariant Sections of the Document, unaltered in their text and
in their titles. Section numbers or the equivalent are not
considered part of the section titles.</para>
<listitem>
<para>Preserve all the Invariant Sections of the Document, unaltered
in their text and in their titles. Section numbers or the equivalent
are not considered part of the section titles.</para>
</listitem>
<listitem><para>Delete any section
entitled "Endorsements". Such a section may not be included in
the Modified Version.</para>
<listitem>
<para>Delete any section entitled "Endorsements". Such a section may
not be included in the Modified Version.</para>
</listitem>
<listitem><para>Do not retitle any
existing section as "Endorsements" or to conflict in title with
any Invariant Section.</para>
<listitem>
<para>Do not retitle any existing section as "Endorsements" or to
conflict in title with any Invariant Section.</para>
</listitem>
</orderedlist>
<para>If the Modified Version includes new front-matter sections
or appendices that qualify as Secondary Sections and contain no
material copied from the Document, you may at your option
designate some or all of these sections as invariant. To do this,
add their titles to the list of Invariant Sections in the Modified
Version's license notice. These titles must be distinct from any
other section titles.</para>
<para>You may add a section entitled "Endorsements", provided it
contains nothing but endorsements of your Modified Version by
various parties--for example, statements of peer review or that
the text has been approved by an organization as the authoritative
definition of a standard.</para>
<para>You may add a passage of up to five words as a Front-Cover
Text, and a passage of up to 25 words as a Back-Cover Text, to the
end of the list of Cover Texts in the Modified Version. Only one
passage of Front-Cover Text and one of Back-Cover Text may be
added by (or through arrangements made by) any one entity. If the
Document already includes a cover text for the same cover,
previously added by you or by arrangement made by the same entity
you are acting on behalf of, you may not add another; but you may
replace the old one, on explicit permission from the previous
publisher that added the old one.</para>
<para>The author(s) and publisher(s) of the Document do not by
this License give permission to use their names for publicity for
or to assert or imply endorsement of any Modified Version.</para>
<para>If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all of
these sections as invariant. To do this, add their titles to the list of
Invariant Sections in the Modified Version's license notice. These titles
must be distinct from any other section titles.</para>
<para>You may add a section entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various parties--for
example, statements of peer review or that the text has been approved by
an organization as the authoritative definition of a standard.</para>
<para>You may add a passage of up to five words as a Front-Cover Text,
and a passage of up to 25 words as a Back-Cover Text, to the end of the
list of Cover Texts in the Modified Version. Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or through
arrangements made by) any one entity. If the Document already includes a
cover text for the same cover, previously added by you or by arrangement
made by the same entity you are acting on behalf of, you may not add
another; but you may replace the old one, on explicit permission from the
previous publisher that added the old one.</para>
<para>The author(s) and publisher(s) of the Document do not by this
License give permission to use their names for publicity for or to assert
or imply endorsement of any Modified Version.</para>
</sect1>
<sect1 label="5" id="gfdl-5">
<title>COMBINING DOCUMENTS</title>
<para>You may combine the Document with other documents released
under this License, under the terms defined in section 4 above for
modified versions, provided that you include in the combination
all of the Invariant Sections of all of the original documents,
unmodified, and list them all as Invariant Sections of your
combined work in its license notice.</para>
<para>The combined work need only contain one copy of this
License, and multiple identical Invariant Sections may be replaced
with a single copy. If there are multiple Invariant Sections with
the same name but different contents, make the title of each such
section unique by adding at the end of it, in parentheses, the
name of the original author or publisher of that section if known,
or else a unique number. Make the same adjustment to the section
titles in the list of Invariant Sections in the license notice of
the combined work.</para>
<para>You may combine the Document with other documents released under
this License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and list
them all as Invariant Sections of your combined work in its license
notice.</para>
<para>The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single copy.
If there are multiple Invariant Sections with the same name but different
contents, make the title of each such section unique by adding at the end
of it, in parentheses, the name of the original author or publisher of
that section if known, or else a unique number. Make the same adjustment
to the section titles in the list of Invariant Sections in the license
notice of the combined work.</para>
<para>In the combination, you must combine any sections entitled
"History" in the various original documents, forming one section
entitled "History"; likewise combine any sections entitled
"Acknowledgements", and any sections entitled "Dedications". You
must delete all sections entitled "Endorsements."</para>
"History" in the various original documents, forming one section entitled
"History"; likewise combine any sections entitled "Acknowledgements", and
any sections entitled "Dedications". You must delete all sections
entitled "Endorsements."</para>
</sect1>
<sect1 label="6" id="gfdl-6">
<title>COLLECTIONS OF DOCUMENTS</title>
<para>You may make a collection consisting of the Document and
other documents released under this License, and replace the
individual copies of this License in the various documents with a
single copy that is included in the collection, provided that you
follow the rules of this License for verbatim copying of each of
the documents in all other respects.</para>
<para>You may extract a single document from such a collection,
and distribute it individually under this License, provided you
insert a copy of this License into the extracted document, and
follow this License in all other respects regarding verbatim
copying of that document.</para>
<para>You may make a collection consisting of the Document and other
documents released under this License, and replace the individual copies
of this License in the various documents with a single copy that is
included in the collection, provided that you follow the rules of this
License for verbatim copying of each of the documents in all other
respects.</para>
<para>You may extract a single document from such a collection, and
distribute it individually under this License, provided you insert a copy
of this License into the extracted document, and follow this License in
all other respects regarding verbatim copying of that document.</para>
</sect1>
<sect1 label="7" id="gfdl-7">
<title>AGGREGATION WITH INDEPENDENT WORKS</title>
<para>A compilation of the Document or its derivatives with other
separate and independent documents or works, in or on a volume of
a storage or distribution medium, does not as a whole count as a
Modified Version of the Document, provided no compilation
copyright is claimed for the compilation. Such a compilation is
called an "aggregate", and this License does not apply to the
other self-contained works thus compiled with the Document, on
account of their being thus compiled, if they are not themselves
derivative works of the Document.</para>
<para>If the Cover Text requirement of section 3 is applicable to
these copies of the Document, then if the Document is less than
one quarter of the entire aggregate, the Document's Cover Texts
may be placed on covers that surround only the Document within the
aggregate. Otherwise they must appear on covers around the whole
aggregate.</para>
separate and independent documents or works, in or on a volume of a
storage or distribution medium, does not as a whole count as a Modified
Version of the Document, provided no compilation copyright is claimed for
the compilation. Such a compilation is called an "aggregate", and this
License does not apply to the other self-contained works thus compiled
with the Document, on account of their being thus compiled, if they are
not themselves derivative works of the Document.</para>
<para>If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one quarter of
the entire aggregate, the Document's Cover Texts may be placed on covers
that surround only the Document within the aggregate. Otherwise they must
appear on covers around the whole aggregate.</para>
</sect1>
<sect1 label="8" id="gfdl-8">
<title>TRANSLATION</title>
<para>Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section
4. Replacing Invariant Sections with translations requires
special permission from their copyright holders, but you may
include translations of some or all Invariant Sections in addition
to the original versions of these Invariant Sections. You may
include a translation of this License provided that you also
include the original English version of this License. In case of
a disagreement between the translation and the original English
version of this License, the original English version will
prevail.</para>
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include translations
of some or all Invariant Sections in addition to the original versions of
these Invariant Sections. You may include a translation of this License
provided that you also include the original English version of this
License. In case of a disagreement between the translation and the
original English version of this License, the original English version
will prevail.</para>
</sect1>
<sect1 label="9" id="gfdl-9">
<title>TERMINATION</title>
<para>You may not copy, modify, sublicense, or distribute the
Document except as expressly provided for under this License. Any
other attempt to copy, modify, sublicense or distribute the
Document is void, and will automatically terminate your rights
under this License. However, parties who have received copies, or
rights, from you under this License will not have their licenses
terminated so long as such parties remain in full
<para>You may not copy, modify, sublicense, or distribute the Document
except as expressly provided for under this License. Any other attempt to
copy, modify, sublicense or distribute the Document is void, and will
automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full
compliance.</para>
</sect1>
<sect1 label="10" id="gfdl-10">
<title>FUTURE REVISIONS OF THIS LICENSE</title>
<para>The Free Software Foundation may publish new, revised
versions of the GNU Free Documentation License from time to time.
Such new versions will be similar in spirit to the present
version, but may differ in detail to address new problems or
concerns. See <ulink
url="http://www.gnu.org/copyleft/">http://www.gnu.org/copyleft/</ulink>.</para>
<para>Each version of the License is given a distinguishing
version number. If the Document specifies that a particular
numbered version of this License "or any later version" applies to
it, you have the option of following the terms and conditions
either of that specified version or of any later version that has
been published (not as a draft) by the Free Software Foundation.
If the Document does not specify a version number of this License,
you may choose any version ever published (not as a draft) by the
Free Software Foundation.</para>
<para>The Free Software Foundation may publish new, revised versions of
the GNU Free Documentation License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in
detail to address new problems or concerns. See
<ulink url="http://www.gnu.org/copyleft/">
http://www.gnu.org/copyleft/</ulink>
.</para>
<para>Each version of the License is given a distinguishing version
number. If the Document specifies that a particular numbered version of
this License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or of
any later version that has been published (not as a draft) by the Free
Software Foundation. If the Document does not specify a version number of
this License, you may choose any version ever published (not as a draft)
by the Free Software Foundation.</para>
</sect1>
<sect1 label="" id="gfdl-howto">
<title>How to use this License for your documents</title>
<para>To use this License in a document you have written, include
a copy of the License in the document and put the following
copyright and license notices just after the title page:</para>
<blockquote><para>
Copyright (c) YEAR YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation;
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
A copy of the license is included in the section entitled "GNU
Free Documentation License".
</para></blockquote>
<para>To use this License in a document you have written, include a copy
of the License in the document and put the following copyright and
license notices just after the title page:</para>
<blockquote>
<para>Copyright (c) YEAR YOUR NAME. Permission is granted to copy,
distribute and/or modify this document under the terms of the GNU Free
Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Sections being LIST
THEIR TITLES, with the Front-Cover Texts being LIST, and with the
Back-Cover Texts being LIST. A copy of the license is included in the
section entitled "GNU Free Documentation License".</para>
</blockquote>
<para>If you have no Invariant Sections, write "with no Invariant
Sections" instead of saying which ones are invariant. If you have
no Front-Cover Texts, write "no Front-Cover Texts" instead of
"Front-Cover Texts being LIST"; likewise for Back-Cover
Texts.</para>
<para>If your document contains nontrivial examples of program
code, we recommend releasing these examples in parallel under your
choice of free software license, such as the GNU General Public
License, to permit their use in free software.</para>
Sections" instead of saying which ones are invariant. If you have no
Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover
Texts being LIST"; likewise for Back-Cover Texts.</para>
<para>If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of free
software license, such as the GNU General Public License, to permit their
use in free software.</para>
</sect1>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -472,3 +445,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/glossary.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook V4.1//EN" > -->
<glossary id="glossary">
<glossary id="glossary">
<glossdiv>
<title>0-9, high ascii</title>
<glossentry>
<glossterm>.htaccess</glossterm>
<glossdef>
<para>
Apache web server, and other NCSA-compliant web servers,
observe the convention of using files in directories
called <filename>.htaccess</filename> files. These
restrict parameters of the web server. In Bugzilla, they
are used to restrict access to certain files which would
otherwise compromise your installation. For instance, the
<filename>localconfig</filename> file contains the
password to your database. If this information were
generally available, and remote access to your database
turned on, you risk corruption of your database by
computer criminals or the curious.
</para>
<para>Apache web server, and other NCSA-compliant web servers,
observe the convention of using files in directories called
<filename>.htaccess</filename>
to restrict access to certain files. In Bugzilla, they are used
to keep secret files which would otherwise
compromise your installation - e.g. the
<filename>localconfig</filename>
file contains the password to your database. If this information were
generally available, and remote access to your database turned on,
you risk corruption of your database by computer criminals or the
curious.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-a">
<title>A</title>
<glossentry>
<glossterm>Apache</glossterm>
<glossdef>
<para>In this context, Apache is the web server most
commonly used for serving up
<glossterm>Bugzilla</glossterm> pages. Contrary to
popular belief, the apache web server has nothing to do
with the ancient and noble Native American tribe, but
instead derived its name from the fact that it was
<quote>a patchy</quote> version of the original
<acronym>NCSA</acronym> world-wide-web server.</para>
<para>In this context, Apache is the web server most commonly used
for serving up
<glossterm>Bugzilla</glossterm>
pages. Contrary to popular belief, the apache web server has nothing
to do with the ancient and noble Native American tribe, but instead
derived its name from the fact that it was
<quote>a patchy</quote>
version of the original
<acronym>NCSA</acronym>
world-wide-web server.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-b">
<title>B</title>
<glossentry>
<glossterm>Bug</glossterm>
<glossdef>
<para>
A <quote>Bug</quote> in Bugzilla refers to an issue
entered into the database which has an associated number,
assignments, comments, etc. Some also refer to a
<quote>tickets</quote> or <quote>issues</quote>; in the
context of Bugzilla, they are synonymous.
</para>
<para>A
<quote>Bug</quote>
in Bugzilla refers to an issue entered into the database which has an
associated number, assignments, comments, etc. Some also refer to a
<quote>tickets</quote>
or
<quote>issues</quote>;
in the context of Bugzilla, they are synonymous.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bug Number</glossterm>
<glossdef>
<para>
Each Bugzilla Bug is assigned a number that uniquely
identifies that Bug. The Bug associated with a Bug Number
can be pulled up via a query, or easily from the very
front page by typing the number in the "Find" box.
</para>
<para>Each Bugzilla Bug is assigned a number that uniquely identifies
that Bug. The Bug associated with a Bug Number can be pulled up via a
query, or easily from the very front page by typing the number in the
"Find" box.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bug Life Cycle</glossterm>
<glossdef>
<para>A Bug has stages through which it must pass before
becoming a <quote>closed bug</quote>, including
acceptance, resolution, and verification. The <quote>Bug
Life Cycle</quote> is moderately flexible according to
the needs of the organization using it, though.</para>
<para>A Bug has stages through which it must pass before becoming a
<quote>closed bug</quote>,
including acceptance, resolution, and verification. The
<quote>Bug Life Cycle</quote>
is moderately flexible according to the needs of the organization
using it, though.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Bugzilla</glossterm>
<glossdef>
<para>
Bugzilla is the industry-standard bug tracking system. It
is quite popular among Open Source enthusiasts.
</para>
<para>Bugzilla is the industry-standard bug tracking system. It is
quite popular among Open Source enthusiasts.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-c">
<title></title>
<title>
</title>
<glossentry id="gloss-component">
<glossterm>Component</glossterm>
<glossdef>
<para>
A Component is a subsection of a Product. It should be a
narrow category, tailored to your organization. All
Products must contain at least one Component (and, as a
matter of fact, creating a Product with no Components will
create an error in Bugzilla).
</para>
<para>A Component is a subsection of a Product. It should be a narrow
category, tailored to your organization. All Products must contain at
least one Component (and, as a matter of fact, creating a Product
with no Components will create an error in Bugzilla).</para>
</glossdef>
</glossentry>
<glossentry id="gloss-cpan">
<glossterm><acronym>CPAN</acronym></glossterm>
<glossterm>
<acronym>CPAN</acronym>
</glossterm>
<glossdef>
<para><acronym>CPAN</acronym> stands for the
<quote>Comprehensive Perl Archive Network</quote>. CPAN
maintains a large number of extremely useful
<glossterm>Perl</glossterm> modules. By themselves, Perl
modules generally do nothing, but when used as part of a
larger program, they provide much-needed algorithms and
functionality.</para>
<para>
<acronym>CPAN</acronym>
stands for the
<quote>Comprehensive Perl Archive Network</quote>
. CPAN maintains a large number of extremely useful
<glossterm>Perl</glossterm>
modules. By themselves, Perl modules generally do nothing, but when
used as part of a larger program, they provide much-needed algorithms
and functionality.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-d">
<title>D</title>
<glossentry>
<glossterm>daemon</glossterm>
<glossdef>
<para>A daemon is a computer program which runs in the
background. In general, most daemons are started at boot
time via System V init scripts, or through RC scripts on
BSD-based systems. <glossterm>mysqld</glossterm>, the
MySQL server, and <glossterm>apache</glossterm>, a web
server, are generally run as daemons.</para>
<para>A daemon is a computer program which runs in the background. In
general, most daemons are started at boot time via System V init
scripts, or through RC scripts on BSD-based systems.
<glossterm>mysqld</glossterm>,
the MySQL server, and
<glossterm>apache</glossterm>,
a web server, are generally run as daemons.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-g">
<title></title>
<title>
</title>
<glossentry>
<glossterm>Groups</glossterm>
<glossdef>
<para>The word <quote>Groups</quote> has a very special
meaning to Bugzilla. Bugzilla's main security mechanism
comes by lumping users into groups, and assigning those
<para>The word
<quote>Groups</quote>
has a very special meaning to Bugzilla. Bugzilla's main security
mechanism comes by lumping users into groups, and assigning those
groups certain privileges to
<glossterm>Products</glossterm> and
<glossterm>Components</glossterm> in the
<glossterm>Bugzilla</glossterm> database.</para>
<glossterm>Products</glossterm>
and
<glossterm>Components</glossterm>
in the
<glossterm>Bugzilla</glossterm>
database.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-i">
<title>I</title>
<glossentry id="gloss-infiniteloop">
<glossterm>Infinite Loop</glossterm>
<glossdef>
<para>A loop of information that never ends; see recursion.</para>
</glossdef>
......@@ -160,144 +198,168 @@
<glossdiv id="gloss-m">
<title>M</title>
<glossentry>
<glossterm>mysqld</glossterm>
<glossdef>
<para>mysqld is the name of the
<glossterm>daemon</glossterm> for the MySQL database. In
general, it is invoked automatically through the use of
the System V init scripts on GNU/Linux and AT&amp;T System
V-based systems, such as Solaris and HP/UX, or through the
RC scripts on BSD-based systems.</para>
<glossterm>daemon</glossterm>
for the MySQL database. In general, it is invoked automatically
through the use of the System V init scripts on GNU/Linux and
AT&amp;T System V-based systems, such as Solaris and HP/UX, or
through the RC scripts on BSD-based systems.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-p">
<title>P</title>
<glossentry>
<glossterm id="gloss-product">Product</glossterm>
<glossdef>
<para>A Product is a broad category of types of bugs. In
general, there are several Components to a Product. A
Product also defines a default Group (used for Bug
Security) for all bugs entered into components beneath
it.</para>
<example>
<title>A Sample Product</title>
<para>A company sells a software product called
<quote>X</quote>. They also maintain some older
software called <quote>Y</quote>, and have a secret
project <quote>Z</quote>. An effective use of Products
might be to create Products <quote>X</quote>,
<quote>Y</quote>, <quote>Z</quote>, each with Components
of User Interface, Database, and Business Logic. They
might also change group permissions so that only those
people who are members of Group <quote>Z</quote> can see
components and bugs under Product
<quote>Z</quote>.</para>
</example>
<para>A Product is a broad category of types of bugs. In general,
there are several Components to a Product. A Product may also define a
group (used for security) for all bugs entered into
components beneath it.</para>
</glossdef>
</glossentry>
<glossentry>
<glossterm>Perl</glossterm>
<glossdef>
<para>First written by Larry Wall, Perl is a remarkable
program language. It has the benefits of the flexibility
of an interpreted scripting language (such as shell
script), combined with the speed and power of a compiled
language, such as C. <glossterm>Bugzilla</glossterm> is
maintained in Perl.</para>
<para>First written by Larry Wall, Perl is a remarkable program
language. It has the benefits of the flexibility of an interpreted
scripting language (such as shell script), combined with the speed
and power of a compiled language, such as C.
<glossterm>Bugzilla</glossterm>
is maintained in Perl.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-q">
<title>Q</title>
<glossentry>
<glossterm>QA</glossterm>
<glossdef>
<para><quote>QA</quote>, <quote>Q/A</quote>, and
<quote>Q.A.</quote> are short for <quote>Quality
Assurance</quote>. In most large software development
organizations, there is a team devoted to ensuring the
product meets minimum standards before shipping. This
team will also generally want to track the progress of
<para>
<quote>QA</quote>,
<quote>Q/A</quote>, and
<quote>Q.A.</quote>
are short for
<quote>Quality Assurance</quote>.
In most large software development organizations, there is a team
devoted to ensuring the product meets minimum standards before
shipping. This team will also generally want to track the progress of
bugs over their life cycle, thus the need for the
<quote>QA Contact</quote> field in a Bug.</para>
<quote>QA Contact</quote>
field in a Bug.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-r">
<title>R</title>
<glossentry id="gloss-recursion" xreflabel="Recursion">
<glossterm>Recursion</glossterm>
<glossdef>
<para>The property of a function looking back at itself for
something. <quote>GNU</quote>, for instance, stands for
<quote>GNU's Not UNIX</quote>, thus recursing upon itself
for definition. For further clarity, see Infinite
Loop.</para>
something.
<quote>GNU</quote>, for instance, stands for
<quote>GNU's Not UNIX</quote>,
thus recursing upon itself for definition. For further clarity, see
Infinite Loop.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-s">
<title>S</title>
<glossentry>
<glossterm><acronym>SGML</acronym></glossterm>
<glossterm>
<acronym>SGML</acronym>
</glossterm>
<glossdef>
<para><acronym>SGML</acronym> stands for <quote>Standard
Generalized Markup Language</quote>. Created in the
1980's to provide an extensible means to maintain
<para>
<acronym>SGML</acronym>
stands for
<quote>Standard Generalized Markup Language</quote>.
Created in the 1980's to provide an extensible means to maintain
documentation based upon content instead of presentation,
<acronym>SGML</acronym> has withstood the test of time as
a robust, powerful language.
<glossterm><acronym>XML</acronym></glossterm> is the
<quote>baby brother</quote> of SGML; any valid
<acronym>XML</acronym> document it, by definition, a valid
<acronym>SGML</acronym> document. The document you are
reading is written and maintained in
<acronym>SGML</acronym>, and is also valid
<acronym>XML</acronym> if you modify the Document Type
Definition.</para>
<acronym>SGML</acronym>
has withstood the test of time as a robust, powerful language.
<glossterm>
<acronym>XML</acronym>
</glossterm>
is the
<quote>baby brother</quote>
of SGML; any valid
<acronym>XML</acronym>
document it, by definition, a valid
<acronym>SGML</acronym>
document. The document you are reading is written and maintained in
<acronym>SGML</acronym>,
and is also valid
<acronym>XML</acronym>
if you modify the Document Type Definition.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-t">
<title>T</title>
<glossentry id="gloss-target-milestone" xreflabel="Target Milestone">
<glossterm>Target Milestone</glossterm>
<glossdef>
<para>
Target Milestones are Product goals. They are
configurable on a per-Product basis. Most software
development houses have a concept of
<quote>milestones</quote> where the people funding a
project expect certain functionality on certain dates.
Bugzilla facilitates meeting these milestones by giving
you the ability to declare by which milestone a bug will be
fixed, or an enhancement will be implemented.
</para>
<para>Target Milestones are Product goals. They are configurable on a
per-Product basis. Most software development houses have a concept of
<quote>milestones</quote>
where the people funding a project expect certain functionality on
certain dates. Bugzilla facilitates meeting these milestones by
giving you the ability to declare by which milestone a bug will be
fixed, or an enhancement will be implemented.</para>
</glossdef>
</glossentry>
</glossdiv>
<glossdiv id="gloss-z">
<title>Z</title>
<glossentry id="zarro-boogs-found" xreflabel="Zarro Boogs Found">
<glossterm>Zarro Boogs Found</glossterm>
<glossdef>
<para>This is the cryptic response sent by Bugzilla when a
query returned no results. It is just a goofy way of
saying "Zero Bugs Found".</para>
<para>This is the cryptic response sent by Bugzilla when a query
returned no results. It is just a goofy way of saying "Zero Bugs
Found".</para>
</glossdef>
</glossentry>
</glossdiv>
</glossary>
</glossary>
<!-- Keep this comment at the end of the file
Local variables:
......@@ -319,3 +381,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/index.xml
View file @ 74bcd6f1
......@@ -18,3 +18,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/integration.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN" > -->
<!-- Keep these tools listings in alphabetical order please. -MPB -->
<chapter id="integration">
<title>Integrating Bugzilla with Third-Party Tools</title>
<section id="bonsai" xreflabel="Bonsai, the Mozilla automated CVS management system">
<section id="bonsai"
xreflabel="Bonsai, the Mozilla automated CVS management system">
<title>Bonsai</title>
<para>Bonsai is a web-based tool for managing <xref
linkend="cvs" />
. Using Bonsai, administrators can control open/closed status
of trees, query a fast relational database back-end for change,
branch, and comment information, and view changes made since the
last time the tree was closed. These kinds of changes cause the
engineer responsible to be <quote>on the hook</quote> (include
cool URL link here for Hook policies at mozilla.org). Bonsai
also includes gateways to <xref
linkend="tinderbox" /> and Bugzilla </para>
<para>Bonsai is a web-based tool for managing
<xref linkend="cvs" />
. Using Bonsai, administrators can control open/closed status of trees,
query a fast relational database back-end for change, branch, and comment
information, and view changes made since the last time the tree was
closed. These kinds of changes cause the engineer responsible to be
<quote>on the hook</quote>
(include cool URL link here for Hook policies at mozilla.org). Bonsai
also includes gateways to
<xref linkend="tinderbox" />
and Bugzilla</para>
</section>
<section id="cvs" xreflabel="CVS, the Concurrent Versioning System">
<title>CVS</title>
<para>CVS integration is best accomplished, at this point, using
the Bugzilla Email Gateway. There have been some files
submitted to allow greater CVS integration, but we need to make
certain that Bugzilla is not tied into one particular software
management package.</para>
<para>
Follow the instructions in the FAQ for enabling Bugzilla e-mail
integration. Ensure that your check-in script sends an email to
your Bugzilla e-mail gateway with the subject of <quote>[Bug
XXXX]</quote>, and you can have CVS check-in comments append
to your Bugzilla bug. If you have your check-in script include
an @resolution field, you can even change the Bugzilla bug
state.
</para>
<para>
There is also a project, based upon somewhat dated Bugzilla
code, to integrate CVS and Bugzilla through CVS' ability to
email. Check it out at:
<para>CVS integration is best accomplished, at this point, using the
Bugzilla Email Gateway. There have been some files submitted to allow
greater CVS integration, but we need to make certain that Bugzilla is not
tied into one particular software management package.</para>
<para>Follow the instructions in the FAQ for enabling Bugzilla e-mail
integration. Ensure that your check-in script sends an email to your
Bugzilla e-mail gateway with the subject of
<quote>[Bug XXXX]</quote>
, and you can have CVS check-in comments append to your Bugzilla bug. If
you have your check-in script include an @resolution field, you can even
change the Bugzilla bug state.</para>
<para>There is also a project, based upon somewhat dated Bugzilla code,
to integrate CVS and Bugzilla through CVS' ability to email. Check it out
at:
<ulink url="http://homepages.kcbbs.gen.nz/~tonyg/">
http://homepages.kcbbs.gen.nz/~tonyg/</ulink>, under the
<quote>cvszilla</quote> link.
</para>
http://homepages.kcbbs.gen.nz/~tonyg/</ulink>
, under the
<quote>cvszilla</quote>
link.</para>
</section>
<section id="scm" xreflabel="Perforce SCM (Fast Software Configuration Management System, a powerful commercial alternative to CVS">
<section id="scm"
xreflabel="Perforce SCM (Fast Software Configuration Management System, a powerful commercial alternative to CVS">
<title>Perforce SCM</title>
<para>
You can find the project page for Bugzilla and Teamtrack
Perforce integration (p4dti) at: <ulink
url="http://www.ravenbrook.com/project/p4dti/"> http://www.ravenbrook.com/project/p4dti</ulink> . <quote>p4dti</quote> is now an officially supported product from Perforce, and you can find the "Perforce Public Depot" p4dti page at <ulink url="http://public.perforce.com/public/perforce/p4dti/index.html"> http://public.perforce.com/public/perforce/p4dti/index.html</ulink>.
</para>
<para>
Integration of Perforce with Bugzilla, once patches are applied,
is seamless. Perforce replication information will appear below
the comments of each bug. Be certain you have a matching set of
patches for the Bugzilla version you are installing. p4dti is
designed to support multiple defect trackers, and maintains its
own documentation for it. Please consult the pages linked above
for further information.
</para>
<para>You can find the project page for Bugzilla and Teamtrack Perforce
integration (p4dti) at:
<ulink url="http://www.ravenbrook.com/project/p4dti/">
http://www.ravenbrook.com/project/p4dti</ulink>
.
<quote>p4dti</quote>
is now an officially supported product from Perforce, and you can find
the "Perforce Public Depot" p4dti page at
<ulink url="http://public.perforce.com/public/perforce/p4dti/index.html">
http://public.perforce.com/public/perforce/p4dti/index.html</ulink>
.</para>
<para>Integration of Perforce with Bugzilla, once patches are applied, is
seamless. Perforce replication information will appear below the comments
of each bug. Be certain you have a matching set of patches for the
Bugzilla version you are installing. p4dti is designed to support
multiple defect trackers, and maintains its own documentation for it.
Please consult the pages linked above for further information.</para>
</section>
<section id="tinderbox" xreflabel="Tinderbox, the Mozilla automated build management system">
<section id="tinderbox"
xreflabel="Tinderbox, the Mozilla automated build management system">
<title>Tinderbox/Tinderbox2</title>
<para>We need Tinderbox integration information.</para>
</section>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -93,3 +108,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/patches.xml
View file @ 74bcd6f1
<!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
<appendix id="patches" xreflabel="Useful Patches and Utilities for Bugzilla">
<title>Useful Patches and Utilities for Bugzilla</title>
<para>Are you looking for a way to put your Bugzilla into overdrive? Catch some of the niftiest tricks here in this section.</para>
<para>Are you looking for a way to put your Bugzilla into overdrive? Catch
some of the niftiest tricks here in this section.</para>
<section id="rewrite" xreflabel="Apache mod_rewrite magic">
<title>Apache <filename>mod_rewrite</filename> magic</title>
<para>Apache's <filename>mod_rewrite</filename> module lets you do some truly amazing things with URL rewriting. Here are a couple of examples of what you can do.</para>
<title>Apache
<filename>mod_rewrite</filename>
magic</title>
<para>Apache's
<filename>mod_rewrite</filename>
module lets you do some truly amazing things with URL rewriting. Here are
a couple of examples of what you can do.</para>
<orderedlist>
<listitem>
<para>
Make it so if someone types
<computeroutput>http://www.foo.com/12345</computeroutput>,
Bugzilla spits back
http://www.foo.com/show_bug.cgi?id=12345. Try setting up
your VirtualHost section for Bugzilla with a rule like
<para>Make it so if someone types
<computeroutput>http://www.foo.com/12345</computeroutput>
, Bugzilla spits back http://www.foo.com/show_bug.cgi?id=12345. Try
setting up your VirtualHost section for Bugzilla with a rule like
this:</para>
<programlisting>
<![CDATA[
<VirtualHost 12.34.56.78>
......@@ -25,96 +34,118 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
</VirtualHost>
]]>
</programlisting>
</listitem>
<listitem>
<para>There are many, many more things you can do with
mod_rewrite. As time goes on, I will include many more in
the Guide. For now, though, please refer to the mod_rewrite
documentation at <ulink
url="http://www.apache.org">http://www.apache.org</ulink></para>
<para>There are many, many more things you can do with mod_rewrite.
As time goes on, I will include many more in the Guide. For now,
though, please refer to the mod_rewrite documentation at
<ulink url="http://www.apache.org">http://www.apache.org</ulink>
</para>
</listitem>
</orderedlist>
</section>
<section id="setperl" xreflabel="The setperl.csh Utility">
<section id="setperl" xreflabel="The setperl.csh Utility">
<title>The setperl.csh Utility</title>
<para> You can use the "setperl.csh" utility to quickly and
easily change the path to perl on all your Bugzilla files. This
is a C-shell script; if you do not have "csh" or "tcsh" in the
search path on your system, it will not work!
</para>
<para>You can use the "setperl.csh" utility to quickly and easily change
the path to perl on all your Bugzilla files. This is a C-shell script; if
you do not have "csh" or "tcsh" in the search path on your system, it
will not work!</para>
<procedure>
<step>
<para>
Download the "setperl.csh" utility to your Bugzilla
directory and make it executable.
</para>
<para>Download the "setperl.csh" utility to your Bugzilla directory
and make it executable.</para>
<substeps>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>cd /your/path/to/bugzilla</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>wget -O
setperl.csh
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=10795'</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>wget -O setperl.csh
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=10795'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>chmod
u+x setperl.csh</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+x setperl.csh</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>
Prepare (and fix) Bugzilla file permissions.
</para>
<para>Prepare (and fix) Bugzilla file permissions.</para>
<substeps>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+w *</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>chmod
u+x duplicates.cgi</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod u+x duplicates.cgi</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput>
<prompt>bash#</prompt>
<command>chmod a-x bug_status.html</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>Run the script:</para>
<para>
Run the script:
</para>
<para>
<computeroutput> <prompt>bash#</prompt>
<computeroutput>
<prompt>bash#</prompt>
<command>./setperl.csh /your/path/to/perl</command>
</computeroutput>
<example>
<example>
<title>Using Setperl to set your perl path</title>
<para>
<computeroutput> <prompt>bash#</prompt>
<computeroutput>
<prompt>bash#</prompt>
<command>./setperl.csh /usr/bin/perl</command>
</computeroutput>
</para>
......@@ -126,78 +157,85 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
<section id="cmdline">
<title>Command-line Bugzilla Queries</title>
<para>
Users can query Bugzilla from the command line using this suite
of utilities.
</para>
<para>
The query.conf file contains the mapping from options to field
names and comparison types. Quoted option names are "grepped"
for, so it should be easy to edit this file. Comments (#) have
no effect; you must make sure these lines do not contain any
quoted "option"
</para>
<para>
buglist is a shell script which submits a Bugzilla query and
writes the resulting HTML page to stdout. It supports both
short options, (such as "-Afoo" or "-Rbar") and long options
(such as "--assignedto=foo" or "--reporter=bar"). If the first
character of an option is not "-", it is treated as if it were
prefixed with "--default=".
</para>
<para>
The columlist is taken from the COLUMNLIST environment variable.
This is equivalent to the "Change Columns" option when you list
bugs in buglist.cgi. If you have already used Bugzilla, use
<command>grep COLUMLIST ~/.netscape/cookies</command> to see
your current COLUMNLIST setting.
</para>
<para>
bugs is a simple shell script which calls buglist and extracts
the bug numbers from the output. Adding the prefix
"http://bugzilla.mozilla.org/buglist.cgi?bug_id=" turns the bug
list into a working link if any bugs are found. Counting bugs is
easy. Pipe the results through <command>sed -e 's/,/ /g' | wc |
awk '{printf $2 "\n"}'</command>
<para>Users can query Bugzilla from the command line using this suite of
utilities.</para>
<para>The query.conf file contains the mapping from options to field
names and comparison types. Quoted option names are "grepped" for, so it
should be easy to edit this file. Comments (#) have no effect; you must
make sure these lines do not contain any quoted "option"</para>
<para>buglist is a shell script which submits a Bugzilla query and writes
the resulting HTML page to stdout. It supports both short options, (such
as "-Afoo" or "-Rbar") and long options (such as "--assignedto=foo" or
"--reporter=bar"). If the first character of an option is not "-", it is
treated as if it were prefixed with "--default=".</para>
<para>The columlist is taken from the COLUMNLIST environment variable.
This is equivalent to the "Change Columns" option when you list bugs in
buglist.cgi. If you have already used Bugzilla, use
<command>grep COLUMLIST ~/.netscape/cookies</command>
to see your current COLUMNLIST setting.</para>
<para>bugs is a simple shell script which calls buglist and extracts the
bug numbers from the output. Adding the prefix
"http://bugzilla.mozilla.org/buglist.cgi?bug_id=" turns the bug list into
a working link if any bugs are found. Counting bugs is easy. Pipe the
results through
<command>sed -e 's/,/ /g' | wc | awk '{printf $2 "\n"}'</command>
</para>
<para>
Akkana says she has good results piping buglist output through
<para>Akkana says she has good results piping buglist output through
<command>w3m -T text/html -dump</command>
</para>
<procedure>
<step>
<para>
Download three files:
</para>
<para>Download three files:</para>
<substeps>
<step>
<para>
<computeroutput> <prompt>bash$</prompt> <command>wget -O
query.conf
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26157'</command> </computeroutput>
<computeroutput>
<prompt>bash$</prompt>
<command>wget -O query.conf
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26157'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash$</prompt> <command>wget -O
buglist
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26944'</command> </computeroutput>
<computeroutput>
<prompt>bash$</prompt>
<command>wget -O buglist
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26944'</command>
</computeroutput>
</para>
</step>
<step>
<para>
<computeroutput> <prompt>bash#</prompt> <command>wget -O
bugs
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26215'</command> </computeroutput>
<computeroutput>
<prompt>bash#</prompt>
<command>wget -O bugs
'http://bugzilla.mozilla.org/showattachment.cgi?attach_id=26215'</command>
</computeroutput>
</para>
</step>
</substeps>
</step>
<step>
<para>
Make your utilities executable:
<para>Make your utilities executable:
<computeroutput>
<prompt>bash$</prompt>
<command>chmod u+x buglist bugs</command>
</computeroutput>
</para>
......@@ -207,275 +245,44 @@ RewriteRule ^/([0-9]+)$ http://foo.bar.com/show_bug.cgi?id=$1 [L,R]
<section id="quicksearch">
<title>The Quicksearch Utility</title>
<para>
Quicksearch is a new, experimental feature of the 2.12 release.
It consist of two Javascript files, "quicksearch.js" and
"localconfig.js", and two documentation files,
"quicksearch.html" and "quicksearchhack.html"
</para>
<para>
The index.html page has been updated to include the QuickSearch
text box.
</para>
<para>
To take full advantage of the query power, the Bugzilla
maintainer must edit "localconfig.js" according to the value
sets used in the local installation.
</para>
<para>
Currently, keywords must be hard-coded in localconfig.js. If
they are not, keywords are not automatically recognized. This
means, if localconfig.js is left unconfigured, that searching
for a bug with the "foo" keyword will only find bugs with "foo"
in the summary, status whiteboard, product or component name,
but not those with the keyword "foo".
</para>
<para>
Workarounds for Bugzilla users:
<simplelist>
<member>search for '!foo' (this will find only bugs with the
keyword "foo"</member>
<member>search 'foo,!foo' (equivalent to 'foo OR
keyword:foo')</member>
</simplelist>
</para>
<para>
When this tool is ported from client-side JavaScript to
server-side Perl, the requirement for hard-coding keywords can
be fixed. <ulink
url="http://bugzilla.mozilla.org/show_bug.cgi?id=70907">This bug</ulink> has details.
</para>
</section>
<section id="bzhacking">
<title>Hacking Bugzilla</title>
<para>
The following is a guide for reviewers when checking code into Bugzilla's
CVS repostory at mozilla.org. If you wish to submit patches to Bugzilla,
you should follow the rules and style conventions below. Any code that
does not adhere to these basic rules will not be added to Bugzilla's
codebase.
</para>
<section>
<title>Things that have caused problems and should be avoided</title>
<orderedlist>
<listitem>
<para>
Usage of variables in Regular Expressions
</para>
<para>
It is very important that you don't use a variable in a regular
expression unless that variable is supposed to contain an expression.
This especially applies when using grep. You should use:
</para>
<para>
<programlisting>
grep ($_ eq $value, @array);
</programlisting>
</para>
<para>
-- NOT THIS --
</para>
<para>
<programlisting>
grep (/$value/, @array);
</programlisting>
</para>
<note>
<para>
If you need to use a non-expression variable inside of an expression, be
sure to quote it properly (using <function>\Q..\E</function>).
</para>
</note>
</listitem>
</orderedlist>
</section>
<section>
<title>Coding Style for Bugzilla</title>
<para>
While it's true that not all of the code currently in Bugzilla adheres to
this (or any) styleguide, it is something that is being worked toward. Therefore,
we ask that all new code (submitted patches and new files) follow this guide
as closely as possible (if you're only changing 1 or 2 lines, you don't have
to reformat the entire file :).
</para>
<para>
The Bugzilla development team has decided to adopt the perl style guide as
published by Larry Wall. This giude can be found in <quote>Programming
Perl</quote> (the camel book) or by typing <command>man perlstyle</command> at
your favorite shell prompt.
</para>
<para>
What appears below if a brief summary, please refer to the perl style
guide if you don't see your question covered here. It is much better to submit
a patch which fails these criteria than no patch at all, but please try to meet
these minimum standards when submitting code to Bugzilla.
</para>
<itemizedlist>
<listitem>
<para>
Whitespace
</para>
<para>
Bugzilla's preferred indentation is 4 spaces (no tabs, please).
</para>
</listitem>
<listitem>
<para>
Curly braces.
</para>
<para>
The opening brace of a block should be on the same line as the statement
that is causing the block and the closing brace should be at the same
indentation level as that statement, for example:
</para>
<para>
<programlisting>
if ($var) {
print "The variable is true";
}
else {
print "Try again";
}
</programlisting>
</para>
<para>
-- NOT THIS --
</para>
<para>
<programlisting>
if ($var)
{
print "The variable is true";
}
else
{
print "Try again";
}
</programlisting>
</para>
</listitem>
<para>Quicksearch is a new, experimental feature of the 2.12 release. It
consist of two Javascript files, "quicksearch.js" and "localconfig.js",
and two documentation files, "quicksearch.html" and
"quicksearchhack.html"</para>
<listitem>
<para>
Cookies
</para>
<para>
Bugzilla uses cookies to ease the user experience, but no new patches
should <emphasis>require</emphasis> user-side cookies.
</para>
</listitem>
<para>The index.html page has been updated to include the QuickSearch
text box.</para>
<listitem>
<para>
File Names
</para>
<para>
File names for bugzilla code and support documention should be legal across
multiple platforms. <computeroutput>\ / : * ? &quot; &lt; &gt;</computeroutput>
and <computeroutput>|</computeroutput> are all illegal characters for filenames
on various platforms. Also, file names should not have spaces in them as they
can cause confusion in CVS and other mozilla.org utilities.
</para>
</listitem>
<para>To take full advantage of the query power, the Bugzilla maintainer
must edit "localconfig.js" according to the value sets used in the local
installation.</para>
<listitem>
<para>
Javascript dependencies
</para>
<para>
While Bugzilla uses Javascript to make the user experience easier, no patch
to Bugzilla should <emphasis>require</emphasis> Javascript.
</para>
</listitem>
<listitem>
<para>
Patch Format
</para>
<para>
All patches submitted for inclusion into Bugzilla should be in the form of a
<quote>unified diff</quote>. This comes from using <quote>diff -u</quote>
instead of simply <quote>diff</quote> when creating your patch. This will
result in quicker acceptance of the patch.
</para>
</listitem>
<listitem>
<para>
Schema Changes
</para>
<para>
If you make schema changes, you should modify <filename>sanitycheck.cgi</filename>
to support the new schema. All referential columns should be checked.
</para>
</listitem>
<para>Currently, keywords must be hard-coded in localconfig.js. If they
are not, keywords are not automatically recognized. This means, if
localconfig.js is left unconfigured, that searching for a bug with the
"foo" keyword will only find bugs with "foo" in the summary, status
whiteboard, product or component name, but not those with the keyword
"foo".</para>
<listitem>
<para>
Taint Mode
</para>
<para>
All new cgis must run in Taint mode (Perl taint and DBI taint), and existing cgi's
which run in taint mode must not have taint mode turned off.
</para>
</listitem>
<para>Workarounds for Bugzilla users:
<simplelist>
<member>search for '!foo' (this will find only bugs with the keyword
"foo"</member>
<listitem>
<para>
Templatization
</para>
<para>
Patches to Bugzilla need to support templates so they do not force user interface choices
on Bugzilla administrators.
<member>search 'foo,!foo' (equivalent to 'foo OR keyword:foo')</member>
</simplelist>
</para>
</listitem>
<listitem>
<para>
Variable Names
</para>
<para>
If a variable is scoped globally (<computeroutput>$::variable</computeroutput>)
its name should be descriptive of what it contains. Local variables can be named
a bit looser, provided the context makes their content obvious. For example,
<computeroutput>$ret</computeroutput> could be used as a staging variable for a
routine's return value as the line <computeroutput>return $ret;</computeroutput>
will make it blatantly obvious what the variable holds and most likely be shown
on the same screen as <computeroutput>my $ret = "";</computeroutput>.
</para>
</listitem>
<para>When this tool is ported from client-side JavaScript to server-side
Perl, the requirement for hard-coding keywords can be fixed.
<ulink url="http://bugzilla.mozilla.org/show_bug.cgi?id=70907">This
bug</ulink>
<listitem>
<para>
Cross Database Compatability
</para>
<para>
Bugzilla was originally written to work with MySQL and therefore took advantage
of some of its features that aren't contained in other RDBMS software. These
should be avoided in all new code. Examples of these features are enums and
<function>encrypt()</function>.
</para>
</listitem>
<listitem>
<para>
Cross Platform Compatability
</para>
<para>
While Bugzilla was written to be used on Unix based systems (and Unix/Linux is
still the only officially supported platform) there are many who desire/need to
run Bugzilla on Microsoft Windows boxes. Whenever possible, we should strive
not to make the lives of these people any more complicated and avoid doing things
that break Bugzilla's ability to run on multiple operating systems.
</para>
</listitem>
</itemizedlist>
</section>
has details.</para>
</section>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -496,3 +303,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/requiredsoftware.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<appendix id="downloadlinks">
<title>Software Download Links</title>
<para>
All of these sites are current as of April, 2001. Hopefully
they'll stay current for a while.
</para>
<para>
Apache Web Server: <ulink url="http://www.apache.org/">http://www.apache.org</ulink>
Optional web server for Bugzilla, but recommended because of broad user base and support.
</para>
<para>
Bugzilla: <ulink url="http://www.mozilla.org/projects/bugzilla/">
http://www.mozilla.org/projects/bugzilla/</ulink>
<para>All of these sites are current as of April, 2001. Hopefully they'll
stay current for a while.</para>
<para>Apache Web Server:
<ulink url="http://www.apache.org/">http://www.apache.org</ulink>
Optional web server for Bugzilla, but recommended because of broad user
base and support.</para>
<para>Bugzilla:
<ulink url="http://www.bugzilla.org/">
http://www.bugzilla.org/</ulink>
</para>
<para>
MySQL: <ulink url="http://www.mysql.com/">http://www.mysql.com/</ulink>
<para>MySQL:
<ulink url="http://www.mysql.com/">http://www.mysql.com/</ulink>
</para>
<para>
Perl: <ulink url="http://www.perl.org">http://www.perl.org/</ulink>
<para>Perl:
<ulink url="http://www.perl.org">http://www.perl.org/</ulink>
</para>
<para>
CPAN: <ulink url="http://www.cpan.org/">http://www.cpan.org/</ulink>
<para>CPAN:
<ulink url="http://www.cpan.org/">http://www.cpan.org/</ulink>
</para>
<para>
DBI Perl module:
<para>DBI Perl module:
<ulink url="http://www.cpan.org/modules/by-module/DBI/">
http://www.cpan.org/modules/by-module/DBI/</ulink>
</para>
<para>
Data::Dumper module:
<para>Data::Dumper module:
<ulink url="http://www.cpan.org/modules/by-module/Data/">
http://www.cpan.org/modules/by-module/Data/</ulink>
</para>
<para>
MySQL related Perl modules:
<para>MySQL related Perl modules:
<ulink url="http://www.cpan.org/modules/by-module/Mysql/">
http://www.cpan.org/modules/by-module/Mysql/</ulink>
</para>
<para>
TimeDate Perl module collection:
<para>TimeDate Perl module collection:
<ulink url="http://www.cpan.org/modules/by-module/Date/">
http://www.cpan.org/modules/by-module/Date/</ulink>
</para>
<para>
GD Perl module:
<para>GD Perl module:
<ulink url="http://www.cpan.org/modules/by-module/GD/">
http://www.cpan.org/modules/by-module/GD/</ulink>
Alternately, you should be able to find the latest version of
GD at <ulink url="http://www.boutell.com/gd/">http://www.boutell.com/gd/</ulink>
Alternately, you should be able to find the latest version of GD at
<ulink url="http://www.boutell.com/gd/">http://www.boutell.com/gd/</ulink>
</para>
<para>
Chart::Base module:
<para>Chart::Base module:
<ulink url="http://www.cpan.org/modules/by-module/Chart/">
http://www.cpan.org/modules/by-module/Chart/</ulink>
</para>
<para>
LinuxDoc Software:
<ulink url="http://www.linuxdoc.org/">http://www.linuxdoc.org/</ulink>
(for documentation maintenance)
</para>
<para>(But remember, Bundle::Bugzilla will install all the modules for you.)
</para>
</appendix>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -84,3 +85,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/using.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
<!-- TOC
Chapter: Using Bugzilla
Create an account
......@@ -26,668 +25,611 @@ Chapter: Using Bugzilla
Miscellaneous usage hints
-->
<chapter id="using">
<title>Using Bugzilla</title>
<epigraph>
<para>
What, Why, How, &amp; Where?
</para>
</epigraph>
<title>Using Bugzilla</title>
<section id="whatis">
<title>What is Bugzilla?</title>
<para>
Bugzilla is one example of a class of programs called "Defect
Tracking Systems", or, more commonly, "Bug-Tracking Systems". Defect
Tracking Systems allow individual or groups of developers to keep
track of outstanding bugs in their product effectively. Bugzilla was
originally written by Terry Weissman in a programming language called
"TCL", to replace a crappy bug-tracking database used internally by
Netscape Communications. Terry later ported Bugzilla to Perl from
TCL, and in Perl it remains to this day. Most commercial
defect-tracking software vendors at the time charged enormous
licensing fees, and Bugzilla quickly became a favorite of the
open-source crowd (with its genesis in the open-source browser
project, Mozilla). It is now the de-facto standard defect-tracking
system against which all others are measured.
</para>
<para>
Bugzilla has matured immensely, and now boasts many advanced features. These include:
<para>Bugzilla is one example of a class of programs called "Defect
Tracking Systems", or, more commonly, "Bug-Tracking Systems". Defect
Tracking Systems allow individual or groups of developers to keep track
of outstanding bugs in their product effectively. Bugzilla was originally
written by Terry Weissman in a programming language called "TCL", to
replace a crappy bug-tracking database used internally by Netscape
Communications. Terry later ported Bugzilla to Perl from TCL, and in Perl
it remains to this day. Most commercial defect-tracking software vendors
at the time charged enormous licensing fees, and Bugzilla quickly became
a favorite of the open-source crowd (with its genesis in the open-source
browser project, Mozilla). It is now the de-facto standard
defect-tracking system against which all others are measured.</para>
<para>Bugzilla has matured immensely, and now boasts many advanced
features. These include:
<itemizedlist>
<listitem>
<para>Powerful searching</para>
</listitem>
<listitem>
<para>User-configurable email notifications of bug changes</para>
</listitem>
<listitem><para>Powerful searching</para></listitem>
<listitem><para>User-configurable email notifications of bug changes</para></listitem>
<listitem><para>Full change history</para></listitem>
<listitem><para>Inter-bug dependency tracking and graphing</para></listitem>
<listitem><para>Excellent attachment management</para></listitem>
<listitem><para>Integrated, product-based, granular security schema</para></listitem>
<listitem><para>Fully security-audited, and runs under Perl's taint mode</para></listitem>
<listitem><para>A robust, stable RDBMS back-end</para></listitem>
<listitem><para>Web, XML, email and console interfaces</para></listitem>
<listitem><para>Completely customisable and/or localisable web user interface</para></listitem>
<listitem><para>Extensive configurability</para></listitem>
<listitem><para>Smooth upgrade pathway between versions</para></listitem>
<listitem>
<para>Full change history</para>
</listitem>
<listitem>
<para>Inter-bug dependency tracking and graphing</para>
</listitem>
<listitem>
<para>Excellent attachment management</para>
</listitem>
<listitem>
<para>Integrated, product-based, granular security schema</para>
</listitem>
<listitem>
<para>Fully security-audited, and runs under Perl's taint mode</para>
</listitem>
<listitem>
<para>A robust, stable RDBMS back-end</para>
</listitem>
<listitem>
<para>Web, XML, email and console interfaces</para>
</listitem>
<listitem>
<para>Completely customisable and/or localisable web user
interface</para>
</listitem>
<listitem>
<para>Extensive configurability</para>
</listitem>
<listitem>
<para>Smooth upgrade pathway between versions</para>
</listitem>
</itemizedlist>
</para>
</section>
<section id="why">
<title>Why Should We Use Bugzilla?</title>
<epigraph>
<para>
No, Who's on first...
</para>
</epigraph>
<para>
For many years, defect-tracking software has remained
principally the domain of large software development houses.
Even then, most shops never bothered with bug-tracking software,
and instead simply relied on shared lists and email to monitor
the status of defects. This procedure is error-prone and tends
to cause those bugs judged least significant by developers to be
dropped or ignored.
</para>
<para>
These days, many companies are finding that integrated
defect-tracking systems reduce downtime, increase productivity,
and raise customer satisfaction with their systems. Along with
full disclosure, an open bug-tracker allows manufacturers to
keep in touch with their clients and resellers, to communicate
about problems effectively throughout the data management chain.
Many corporations have also discovered that defect-tracking
helps reduce costs by providing IT support accountability,
telephone support knowledge bases, and a common, well-understood
system for accounting for unusual system or software issues.
</para>
<para>
But why should <emphasis>you</emphasis> use Bugzilla?
</para>
<para>
Bugzilla is very adaptable to various situations. Known uses
currently include IT support queues, Systems Administration
deployment management, chip design and development problem
tracking (both pre-and-post fabrication), and software and
hardware bug tracking for luminaries such as Redhat, Loki
software, Linux-Mandrake, and VA Systems. Combined with systems
such as CVS, Bonsai, or Perforce SCM, Bugzilla provides a
powerful, easy-to-use solution to configuration management and
replication problems
</para>
<para>
Bugzilla can dramatically increase the productivity and
accountability of individual employees by providing a documented
workflow and positive feedback for good performance. How many
times do you wake up in the morning, remembering that you were
supposed to do <emphasis>something</emphasis> today, but you
just can't quite remember? Put it in Bugzilla, and you have a
record of it from which you can extrapolate milestones, predict
<para>For many years, defect-tracking software has remained principally
the domain of large software development houses. Even then, most shops
never bothered with bug-tracking software, and instead simply relied on
shared lists and email to monitor the status of defects. This procedure
is error-prone and tends to cause those bugs judged least significant by
developers to be dropped or ignored.</para>
<para>These days, many companies are finding that integrated
defect-tracking systems reduce downtime, increase productivity, and raise
customer satisfaction with their systems. Along with full disclosure, an
open bug-tracker allows manufacturers to keep in touch with their clients
and resellers, to communicate about problems effectively throughout the
data management chain. Many corporations have also discovered that
defect-tracking helps reduce costs by providing IT support
accountability, telephone support knowledge bases, and a common,
well-understood system for accounting for unusual system or software
issues.</para>
<para>But why should
<emphasis>you</emphasis>
use Bugzilla?</para>
<para>Bugzilla is very adaptable to various situations. Known uses
currently include IT support queues, Systems Administration deployment
management, chip design and development problem tracking (both
pre-and-post fabrication), and software and hardware bug tracking for
luminaries such as Redhat, Loki software, Linux-Mandrake, and VA Systems.
Combined with systems such as CVS, Bonsai, or Perforce SCM, Bugzilla
provides a powerful, easy-to-use solution to configuration management and
replication problems</para>
<para>Bugzilla can dramatically increase the productivity and
accountability of individual employees by providing a documented workflow
and positive feedback for good performance. How many times do you wake up
in the morning, remembering that you were supposed to do
<emphasis>something</emphasis>
today, but you just can't quite remember? Put it in Bugzilla, and you
have a record of it from which you can extrapolate milestones, predict
product versions for integration, and by using Bugzilla's e-mail
integration features be able to follow the discussion trail that
led to critical decisions.
</para>
<para>
Ultimately, Bugzilla puts the power in your hands to improve
your value to your employer or business while providing a usable
framework for your natural attention to detail and knowledge
store to flourish.
</para>
integration features be able to follow the discussion trail that led to
critical decisions.</para>
<para>Ultimately, Bugzilla puts the power in your hands to improve your
value to your employer or business while providing a usable framework for
your natural attention to detail and knowledge store to flourish.</para>
</section>
<section id="how">
<title>How do I use Bugzilla?</title>
<epigraph>
<para>
Hey! I'm Woody! Howdy, Howdy, Howdy!
</para>
</epigraph>
<para>
This section contains information for end-users of Bugzilla.
If you are administering a Bugzilla installation, please consult the
Installing and Administering Bugzilla portions of this Guide.
</para>
<para>
There is a Bugzilla test installation, called
<ulink url="http://landfill.tequilarista.org/">
Landfill</ulink>, which you are welcome to play with.
However, it does not necessarily have all Bugzilla features
enabled, and often runs cutting-edge versions of Bugzilla for
testing, so some things may work slightly differently than
mentioned here.
</para>
<para>This section contains information for end-users of Bugzilla. If you
are administering a Bugzilla installation, please consult the Installing
and Administering Bugzilla portions of this Guide.</para>
<para>There is a Bugzilla test installation, called
<ulink url="http://landfill.tequilarista.org/">Landfill</ulink>
, which you are welcome to play with. However, it does not necessarily
have all Bugzilla features enabled, and often runs cutting-edge versions
of Bugzilla for testing, so some things may work slightly differently
than mentioned here.</para>
<section id="myaccount">
<title>Create a Bugzilla Account</title>
<para>
If you want to use Bugzilla, first you
need to create an account. Consult with the administrator
responsible for your installation of Bugzilla for the URL you
should use to access it. If you're test-driving Bugzilla,
use this URL: <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/"> http://landfill.tequilarista.org/bugzilla-tip/</ulink>
<para>If you want to use Bugzilla, first you need to create an account.
Consult with the administrator responsible for your installation of
Bugzilla for the URL you should use to access it. If you're
test-driving Bugzilla, use this URL:
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/">
http://landfill.tequilarista.org/bugzilla-tip/</ulink>
</para>
<orderedlist>
<listitem>
<para>
Click the <quote>Open a new Bugzilla account</quote> link, enter your
email address and, optionally, your name in the spaces provided,
then click <quote>Create Account</quote>.
</para>
<para>Click the
<quote>Open a new Bugzilla account</quote>
link, enter your email address and, optionally, your name in the
spaces provided, then click
<quote>Create Account</quote>
.</para>
</listitem>
<listitem>
<para>
Within moments, you should receive an email to the address
you provided above, which contains your login name
(generally the same as the email address), and a password
you can use to access your account. This password is
randomly generated, and can be changed to something more memorable.
</para>
<para>Within moments, you should receive an email to the address
you provided above, which contains your login name (generally the
same as the email address), and a password you can use to access
your account. This password is randomly generated, and can be
changed to something more memorable.</para>
</listitem>
<listitem>
<para>
Click the <quote>Log In</quote> link in the yellow area at
the bottom of the page in your browser, enter your
email address and password into the spaces provided, and click
<quote>Login</quote>.
</para>
<para>Click the
<quote>Log In</quote>
link in the yellow area at the bottom of the page in your browser,
enter your email address and password into the spaces provided, and
click
<quote>Login</quote>
.</para>
</listitem>
</orderedlist>
<para>
You are now logged in. Bugzilla uses cookies for authentication, so
(unless your IP address changes) you should not have to log in again.
</para>
<para>You are now logged in. Bugzilla uses cookies for authentication,
so (unless your IP address changes) you should not have to log in
again.</para>
</section>
<section id="bug_page">
<title>Anatomy of a Bug</title>
<para>
The core of Bugzilla is the screen which displays a particular bug.
It's a good place to explain some Bugzilla concepts.
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/show_bug.cgi?id=1">Bug 1 on Landfill</ulink> is a good example. Note that the names of most fields
are hyperlinks; clicking them will take you to context-sensitive
help on that particular field.
</para>
<para>The core of Bugzilla is the screen which displays a particular
bug. It's a good place to explain some Bugzilla concepts.
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/show_bug.cgi?id=1">
Bug 1 on Landfill</ulink>
is a good example. Note that the names of most fields are hyperlinks;
clicking them will take you to context-sensitive help on that
particular field.</para>
<orderedlist>
<listitem>
<para>
<emphasis>Product and Component</emphasis>:
Bugs are divided up by Product and Component, with a Product having one
or more Components in it. For example, bugzilla.mozilla.org's
"Bugzilla" Product is composed of several Components:
<emphasis>Product and Component</emphasis>
: Bugs are divided up by Product and Component, with a Product
having one or more Components in it. For example,
bugzilla.mozilla.org's "Bugzilla" Product is composed of several
Components:
<simplelist>
<member><emphasis>Administration</emphasis>,
Administration of a bugzilla installation, including
<filename>editcomponents.cgi</filename>,
<filename>editgroups.cgi</filename>,
<filename>editkeywords.cgi</filename>,
<filename>editparams.cgi</filename>,
<filename>editproducts.cgi</filename>,
<filename>editusers.cgi</filename>,
<filename>editversions.cgi,</filename> and
<filename>sanitycheck.cgi</filename>.
</member>
<member><emphasis>Bugzilla-General</emphasis>,
<member>
<emphasis>Administration:</emphasis>
Administration of a Bugzilla installation.</member>
<member>
<emphasis>Bugzilla-General:</emphasis>
Anything that doesn't fit in the other components, or spans
multiple components.
</member>
<member><emphasis>Creating/Changing Bugs</emphasis>,
Creating, changing, and viewing bugs.
<filename>enter_bug.cgi</filename>,
<filename>post_bug.cgi</filename>,
<filename>show_bug.cgi</filename> and
<filename>process_bug.cgi</filename>.
</member>
<member><emphasis>Documentation</emphasis>,
The bugzilla documentation, including anything in the
<filename>docs/</filename> directory and The Bugzilla Guide
</member>
<member><emphasis>Email</emphasis>,
Anything to do with email sent by Bugzilla.
<filename>processmail</filename>
</member>
<member><emphasis>Installation</emphasis>,
The installation process of Bugzilla. This includes
<filename>checksetup.pl</filename> and whatever else it evolves into.
</member>
<member><emphasis>Query/Buglist</emphasis>,
Anything to do with searching for bugs and viewing the buglists.
<filename>query.cgi</filename> and
<filename>buglist.cgi</filename>
</member>
<member><emphasis>Reporting/Charting</emphasis>,
Getting reports from Bugzilla.
<filename>reports.cgi</filename> and
<filename>duplicates.cgi</filename>
</member>
<member><emphasis>User Accounts</emphasis>,
multiple components.</member>
<member>
<emphasis>Creating/Changing Bugs:</emphasis>
Creating, changing, and viewing bugs.</member>
<member>
<emphasis>Documentation:</emphasis>
The Bugzilla documentation, including The Bugzilla Guide.</member>
<member>
<emphasis>Email:</emphasis>
Anything to do with email sent by Bugzilla.</member>
<member>
<emphasis>Installation:</emphasis>
The installation process of Bugzilla.</member>
<member>
<emphasis>Query/Buglist:</emphasis>
Anything to do with searching for bugs and viewing the
buglists.</member>
<member>
<emphasis>Reporting/Charting:</emphasis>
Getting reports from Bugzilla.</member>
<member>
<emphasis>User Accounts:</emphasis>
Anything about managing a user account from the user's perspective.
<filename>userprefs.cgi</filename>, saved queries, creating accounts,
changing passwords, logging in, etc.
</member>
<member><emphasis>User Interface</emphasis>,
Saved queries, creating accounts, changing passwords, logging in,
etc.</member>
<member>
<emphasis>User Interface:</emphasis>
General issues having to do with the user interface cosmetics (not
functionality) including cosmetic issues, HTML templates, etc.
</member>
functionality) including cosmetic issues, HTML templates,
etc.</member>
</simplelist>
</para>
</listitem>
<listitem>
<para>
<emphasis>Status and Resolution</emphasis>:
A bug passes through several Statuses in its lifetime, and ends up in the
RESOLVED status, with one of a set of Resolutions (e.g. FIXED, INVALID.)
The different possible
values for Status and Resolution on your installation will be documented
in the context-sensitive help for those items.
</para>
<emphasis>Status and Resolution:</emphasis>
A bug passes through several Statuses in its lifetime, and ends up
in the RESOLVED status, with one of a set of Resolutions (e.g.
FIXED, INVALID.) The different possible values for Status and
Resolution on your installation will be documented in the
context-sensitive help for those items.</para>
</listitem>
<listitem>
<para>
<emphasis>Assigned To</emphasis>:
The person responsible for fixing the bug.
</para>
<emphasis>Assigned To:</emphasis>
The person responsible for fixing the bug.</para>
</listitem>
<listitem>
<para>
<emphasis>URL</emphasis>:
A URL associated with the bug, if any.
</para>
<emphasis>URL:</emphasis>
A URL associated with the bug, if any.</para>
</listitem>
<listitem>
<para>
<emphasis>Summary</emphasis>:
A one-sentence summary of the problem.
</para>
<emphasis>Summary:</emphasis>
A one-sentence summary of the problem.</para>
</listitem>
<listitem>
<para>
<emphasis>Status Whiteboard</emphasis>: (a.k.a. Whiteboard) A
free-form text area for adding short notes and tags to a bug.
</para>
<emphasis>Status Whiteboard:</emphasis>
(a.k.a. Whiteboard) A free-form text area for adding short notes
and tags to a bug.</para>
</listitem>
<listitem>
<para>
<emphasis>Keywords</emphasis>:
<emphasis>Keywords:</emphasis>
The administrator can define keywords which you can use to tag and
categorise bugs - e.g. The Mozilla Project has keywords like crash
and regression.
</para>
and regression.</para>
</listitem>
<listitem>
<para>
<emphasis>Platform and OS</emphasis>:
These indicate the computing environment where the bug was found.
</para>
<emphasis>Platform and OS:</emphasis>
These indicate the computing environment where the bug was
found.</para>
</listitem>
<listitem>
<para>
<emphasis>Version</emphasis>:
The "Version" field is usually used for versions of a product which have
been released, and is set to indicate which versions of a Component
have the particular problem the bug report is about.
</para>
<emphasis>Version:</emphasis>
The "Version" field is usually used for versions of a product which
have been released, and is set to indicate which versions of a
Component have the particular problem the bug report is
about.</para>
</listitem>
<listitem>
<para>
<emphasis>Priority</emphasis>:
The bug assignee uses this field to prioritise his or her bugs. It's
a good idea not to change this on other people's bugs.
</para>
<emphasis>Priority:</emphasis>
The bug assignee uses this field to prioritise his or her bugs.
It's a good idea not to change this on other people's bugs.</para>
</listitem>
<listitem>
<para>
<emphasis>Severity</emphasis>:
This indicates how severe the problem is - from blocker ("application
unusable") to trivial ("minor cosmetic issue"). You can also use this
field to indicate whether a bug is an enhancement request.
</para>
<emphasis>Severity:</emphasis>
This indicates how severe the problem is - from blocker
("application unusable") to trivial ("minor cosmetic issue"). You
can also use this field to indicate whether a bug is an enhancement
request.</para>
</listitem>
<listitem>
<para>
<emphasis>Target</emphasis>:
(a.k.a. Target Milestone) A future version by which the bug is to be
fixed. e.g. The Bugzilla Project's milestones for future
Bugzilla versions are 2.18, 2.20, 3.0, etc. Milestones are
not restricted to numbers, thought - you can use any text strings,
such as dates.
</para>
<emphasis>Target:</emphasis>
(a.k.a. Target Milestone) A future version by which the bug is to
be fixed. e.g. The Bugzilla Project's milestones for future
Bugzilla versions are 2.18, 2.20, 3.0, etc. Milestones are not
restricted to numbers, thought - you can use any text strings, such
as dates.</para>
</listitem>
<listitem>
<para>
<emphasis>Reporter</emphasis>:
The person who filed the bug.
</para>
<emphasis>Reporter:</emphasis>
The person who filed the bug.</para>
</listitem>
<listitem>
<para>
<emphasis>CC list</emphasis>:
A list of people who get mail when the bug changes.
</para>
<emphasis>CC list:</emphasis>
A list of people who get mail when the bug changes.</para>
</listitem>
<listitem>
<para>
<emphasis>Attachments</emphasis>:
You can attach files (e.g. testcases or patches) to bugs. If there are
any attachments, they are listed in this section.
</para>
<emphasis>Attachments:</emphasis>
You can attach files (e.g. testcases or patches) to bugs. If there
are any attachments, they are listed in this section.</para>
</listitem>
<listitem>
<para>
<emphasis>Dependencies</emphasis>:
If this bug cannot be fixed unless other bugs are fixed (depends on), or
this bug stops other bugs being fixed (blocks), their numbers are
recorded here.
</para>
<emphasis>Dependencies:</emphasis>
If this bug cannot be fixed unless other bugs are fixed (depends
on), or this bug stops other bugs being fixed (blocks), their
numbers are recorded here.</para>
</listitem>
<listitem>
<para>
<emphasis>Votes</emphasis>:
Whether this bug has any votes.
</para>
<emphasis>Votes:</emphasis>
Whether this bug has any votes.</para>
</listitem>
<listitem>
<para>
<emphasis>Additional Comments</emphasis>:
<emphasis>Additional Comments:</emphasis>
You can add your two cents to the bug discussion here, if you have
something worthwhile to say.
</para>
something worthwhile to say.</para>
</listitem>
</orderedlist>
</section>
<section id="query">
<title>Searching for Bugs</title>
<para>
The Bugzilla Search page is is the interface where you can
find any bug report, comment, or patch currently in the
Bugzilla system. You can play with it here:
<para>The Bugzilla Search page is is the interface where you can find
any bug report, comment, or patch currently in the Bugzilla system. You
can play with it here:
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi">
landfill.tequilarista.org/bugzilla-tip/query.cgi</ulink>.
</para>
landfill.tequilarista.org/bugzilla-tip/query.cgi</ulink>
<para>
The Search page has controls for selecting different possible values
for all of the fields in a bug, as described above. Once you've defined
a search, you can either run it, or save it as a Remembered Query, which
can optionally appear in the footer of your pages.
</para>
.</para>
<para>
Highly advanced querying is done using Boolean Charts, which have their
own <ulink url="http://landfill.tequilarista.org/bugzilla-tip/booleanchart.html">context-sensitive help</ulink>.
</para>
<para>The Search page has controls for selecting different possible
values for all of the fields in a bug, as described above. Once you've
defined a search, you can either run it, or save it as a Remembered
Query, which can optionally appear in the footer of your pages.</para>
<para>Highly advanced querying is done using Boolean Charts, which have
their own
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/booleanchart.html">
context-sensitive help</ulink>
.</para>
</section>
<section id="list">
<title>Bug Lists</title>
<para>
If you run a search, a list of matching bugs will be returned.
The default search is to return all open bugs on the system -
don't try running this search on a Bugzilla installation with
a lot of bugs!
</para>
<para>
The format of the list is configurable. For example, it can be
sorted by clicking the column headings. Other useful features
can be accessed using the links at the bottom of the list:
<para>If you run a search, a list of matching bugs will be returned.
The default search is to return all open bugs on the system - don't try
running this search on a Bugzilla installation with a lot of
bugs!</para>
<para>The format of the list is configurable. For example, it can be
sorted by clicking the column headings. Other useful features can be
accessed using the links at the bottom of the list:
<simplelist>
<member><emphasis>Long Format</emphasis>: this gives you a large page
with a non-editable summary of the fields of each bug.</member>
<member><emphasis>Change Columns</emphasis>: change the bug
attributes which appear in the list.</member>
<member><emphasis>Change several bugs at once</emphasis>: If
your account is sufficiently empowered, you can make the same
<member>
<emphasis>Long Format:</emphasis>
this gives you a large page with a non-editable summary of the fields
of each bug.</member>
<member>
<emphasis>Change Columns:</emphasis>
change the bug attributes which appear in the list.</member>
<member>
<emphasis>Change several bugs at once:</emphasis>
If your account is sufficiently empowered, you can make the same
change to all the bugs in the list - for example, changing their
owner.</member>
<member><emphasis>Send mail to bug owners</emphasis>: Sends mail
to the owners of all bugs on the list.</member>
<member><emphasis>Edit this query</emphasis>: If you didn't
get exactly the results you were looking for, you can
return to the Query page through this link and make small
revisions to the query you just made so you get more
accurate results.</member>
<member>
<emphasis>Send mail to bug owners:</emphasis>
Sends mail to the owners of all bugs on the list.</member>
<member>
<emphasis>Edit this query:</emphasis>
If you didn't get exactly the results you were looking for, you can
return to the Query page through this link and make small revisions
to the query you just made so you get more accurate results.</member>
</simplelist>
</para>
</section>
<section id="bugreports">
<title>Filing Bugs</title>
<epigraph>
<para>And all this time, I thought we were taking bugs <emphasis>out</emphasis>...</para>
</epigraph>
<para>
Years of bug writing experience has been distilled for your reading
pleasure into the <ulink url="http://landfill.tequilarista.org/bugzilla-tip/bugwritinghelp.html">
Bug Writing Guidelines</ulink>.
While some of the advice is Mozilla-specific, the basic principles of reporting Reproducible, Specific bugs, isolating the Product you are using, the Version of the Product, the Component which failed, the Hardware Platform, and Operating System you were using at the time of the failure go a long way toward ensuring accurate, responsible fixes for the bug that bit you.
</para>
<para>
The procedure for filing a test bug is as follows:
</para>
<para>Years of bug writing experience has been distilled for your
reading pleasure into the
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/bugwritinghelp.html">
Bug Writing Guidelines</ulink>
. While some of the advice is Mozilla-specific, the basic principles of
reporting Reproducible, Specific bugs, isolating the Product you are
using, the Version of the Product, the Component which failed, the
Hardware Platform, and Operating System you were using at the time of
the failure go a long way toward ensuring accurate, responsible fixes
for the bug that bit you.</para>
<para>The procedure for filing a test bug is as follows:</para>
<orderedlist>
<listitem>
<para>
Go to <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/">Landfill</ulink>
<para>Go to
<ulink url="http://landfill.tequilarista.org/bugzilla-tip/">
Landfill</ulink>
in your browser and click
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/enter_bug.cgi"> Enter a new bug report</ulink>.
</para>
url="http://landfill.tequilarista.org/bugzilla-tip/enter_bug.cgi">
Enter a new bug report</ulink>
.</para>
</listitem>
<listitem>
<para>
Select a product - any one will do.
</para>
<para>Select a product - any one will do.</para>
</listitem>
<listitem>
<para>
Fill in the fields.
Bugzilla should have made reasonable guesses, based upon
your browser, for the "Platform" and "OS" drop-down
boxes. If they are wrong, change them.
</para>
<para>Fill in the fields. Bugzilla should have made reasonable
guesses, based upon your browser, for the "Platform" and "OS"
drop-down boxes. If they are wrong, change them.</para>
</listitem>
<listitem>
<para>
Select "Commit" and send in your bug report.
</para>
<para>Select "Commit" and send in your bug report.</para>
</listitem>
</orderedlist>
</section>
</section>
<section id="init4me">
<title>Where can I find my user preferences?</title>
<epigraph>
<para>
Indiana, it feels like we walking on fortune cookies!
</para>
<para>
These ain't fortune cookies, kid...
</para>
</epigraph>
<para>
Customized User Preferences offer tremendous versatility to your
individual Bugzilla experience. Let's plunge into what you can
do! The first step is to click the "Edit prefs" link at the
footer of each page once you have logged in to <ulink
url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi?GoAheadAndLogIn=1"> Landfill</ulink>.
</para>
<title>User Preferences</title>
<para>You can customise various aspects of Bugzilla, via the "Edit prefs"
link in the page footer, once you have logged in, e.g. to
<ulink
url="http://landfill.tequilarista.org/bugzilla-tip/query.cgi?GoAheadAndLogIn=1">
Landfill</ulink>
. The preferences are split into four tabs.</para>
<section id="accountsettings" xreflabel="Account Settings">
<title>Account Settings</title>
<para>
On this page, you can change your basic Account Settings,
including your password and full name. For security reasons,
in order to change anything on this page you must type your
<emphasis>current</emphasis> password into the <quote>Old
Password</quote> field. If you wish to change your
password, type the new password you want into the <quote>New
Password</quote> field and again into the <quote>Re-enter
new password</quote> field to ensure you typed your new
password correctly. Select the <quote>Submit</quote> button
and you are done.
</para>
<para>On this tab, you can change your basic Account Settings,
including your password, email address and real name. For security
reasons, in order to change anything on this page you must type your
<emphasis>current</emphasis>
password into the
<quote>Password</quote>
field. If you attempt to change your email address, a confirmation
email is sent to both the old and new addresses, with a link to use to
confirm the change. This helps to prevent account hijacking.</para>
</section>
<section id="emailsettings" >
<section id="emailsettings">
<title>Email Settings</title>
<section id="notification" xreflabel="">
<title>Email Notification</title>
<para>
Here you can reduce or increase the amount of email sent you
from Bugzilla. Although this is referred to as
<quote>Advanced Email Filtering Options</quote>, they are,
in fact, the standard email filter set. All of them are
self-explanatory, but you can use the filters in interesting
ways. For instance, some people (notably Quality Assurance
personnel) often only care to receive updates regarding a
bug when the bug changes state, so they can track bugs on
their flow charts and know when it is time to pull the bug
onto a quality assurance platform for inspection. Other
people set up email gateways to
<xref linkend="bonsai" /> or <xref linkend="tinderbox" />, and
restrict which types of Bugzilla information are fed to
these systems..
</para>
</section>
<section id="newemailtech">
<title>New Email Technology</title>
<note>
<para>
This option may not be available in all Bugzilla
installations, depending upon the preferences of the
systems administrator responsible for the setup of your
Bugzilla. However, if you really want this functionality,
ask her to "enable newemailtech in Params" and "make it
the default for all new users", referring her to the
Administration section of this Guide.
</para>
</note>
<para>
Disregard the warnings about "experimental and bleeding
edge"; the code to handle email in a cleaner manner than
that historically used for Bugzilla is quite robust and
well-tested now.
</para>
<para>
I recommend you enable the option, "Click here to sign up
(and risk any bugs)". Your email-box will thank you for it.
The fundamental shift in "newemailtech" is away from
standard UNIX "diff" output, which is quite ugly, to a
prettier, better laid-out email.
</para>
</section>
<section id="watchsettings">
<title>"Watching" Users</title>
<para>On this tab you can reduce or increase the amount of email sent
you from Bugzilla, opting in our out depending on your relationship to
the bug and the change that was made to it. (Note that you can also do
client-side filtering using the X-Bugzilla-Reason header which Bugzilla
adds to all bugmail.)</para>
<para>By entering user email names, delineated by commas, into the
"Users to watch" text entry box you can receive a copy of all the
bugmail of other users (security settings permitting.) This powerful
functionality enables seamless transitions as developers change
projects, managers wish to get in touch with the issues faced by their
direct reports, or users go on vacation.</para>
<note>
<para>
This option may not be available in all Bugzilla
installations, depending upon the preferences of the
systems administrator responsible for the setup of your
Bugzilla. However, if you really want this functionality,
ask her to "enable watchers in Params".
</para>
<para>This option may not be available in all Bugzilla installations.
Ask your administrator.</para>
</note>
<para>
By entering user email names into the "Users to watch" text
entry box, delineated by commas, you can watch bugs of other
users. This powerful functionality enables seamless
transitions as developers change projects, managers wish to
get in touch with the issues faced by their direct reports,
or users go on vacation. If any of these three situations
apply to you, you will undoubtedly find this feature quite
convenient.
</para>
</section>
</section>
<section id="footersettings">
<title>Page Footer</title>
<note>
<para>
By default, this page is quite barren. However, go explore
the Query Page some more; you will find that you can store
numerous queries on the server, so if you regularly run a
particular query it is just a drop-down menu away. On this
page of Preferences, if you have many stored queries you can
elect to have them always one-click away!
</para>
</note>
<para>
If you have many stored queries on the server, here you will
find individual drop-downs for each stored query. Each
drop-down gives you the option of that query appearing on the
footer of every page in Bugzilla! This gives you powerful
one-click access to any complex searches you may set up, and
is an excellent way to impress your boss...
</para>
<tip>
<para>By default, the "My Bugs" link appears at the bottom of
each page. However, this query gives you both the bugs you
have reported, as well as those you are assigned. One of
the most common uses for this page is to remove the "My
Bugs" link, replacing it with two other queries, commonly
called "My Bug Reports" and "My Bugs" (but only referencing
bugs assigned to you). This allows you to distinguish those
bugs you have reported from those you are assigned. I
commonly set up complex Boolean queries in the Query page
and link them to my footer in this page. When they are
significantly complex, a one-click reference can save hours
of work.</para>
</tip>
<para>By default, this page is quite barren. However, if you explore
the Search page some more, you will find that you can store numerous
queries on the server, so if you regularly run a particular query it is
just a drop-down menu away. Once you have a stored query, you can come
here to request that it also be displayed in your page footer.</para>
</section>
<section id="permissionsettings">
<title>Permissions</title>
<para>
This is a purely informative page which outlines your current
permissions on this installation of Bugzilla. If you have
permissions to grant certain permissions to other users, the
"other users" link appears on this page as well as the footer.
For more information regarding user administration, please
consult the Administration section of this Guide.
</para>
</section>
</section>
<section id="usingbz-conc">
<title>Using Bugzilla-Conclusion</title>
<para>
Thank you for reading through this portion of the Bugzilla
Guide. I anticipate it may not yet meet the needs of all
readers. If you have additional comments or corrections to
make, please submit your contributions to the <ulink
url="mailto://mozilla-webtools@mozilla.org">mozilla-webtools</ulink> mailing list/newsgroup. The mailing list is mirrored to the netscape.public.mozilla.webtools newsgroup, and the newsgroup is mirrored to mozilla-webtools@mozilla.org
</para>
<para>This is a purely informative page which outlines your current
permissions on this installation of Bugzilla - what product groups you
are in, and whether you can edit bugs or perform various administration
functions.</para>
</section>
</section>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
......@@ -708,3 +650,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
docs/xml/variants.xml
View file @ 74bcd6f1
<!-- <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook V4.1//EN">-->
<chapter id="variants" xreflabel="Bugzilla Variants and Competitors">
<title>Bugzilla Variants and Competitors</title>
<para>I created this section to answer questions about Bugzilla
competitors and variants, then found a wonderful site which covers
an awful lot of what I wanted to discuss. Rather than quote it in
its entirety, I'll simply refer you here: <ulink
url="http://linas.org/linux/pm.html">http://linas.org/linux/pm.html</ulink></para>
<para>I created this section to answer questions about Bugzilla competitors
and variants, then found a wonderful site which covers an awful lot of what
I wanted to discuss. Rather than quote it in its entirety, I'll simply
refer you here:
<ulink url="http://linas.org/linux/pm.html">
http://linas.org/linux/pm.html</ulink>
</para>
<section id="rhbugzilla" xreflabel="Red Hat Bugzilla">
<title>Red Hat Bugzilla</title>
<para>
Red Hat Bugzilla is probably the most popular Bugzilla variant
on the planet. One of the major benefits of Red Hat Bugzilla is
the ability to work with Oracle, MySQL, and PostGreSQL databases
serving as the back-end, instead of just MySQL. Dave Lawrence
has worked very hard to keep Red Hat Bugzilla up-to-date, and
many people prefer the snappier-looking page layout of Red Hat
Bugzilla to the default Mozilla-standard formatting.
<para>Red Hat Bugzilla is probably the most popular Bugzilla variant on
the planet. One of the major benefits of Red Hat Bugzilla is the ability
to work with Oracle, MySQL, and PostGreSQL databases serving as the
back-end, instead of just MySQL. Dave Lawrence has worked very hard to
keep Red Hat Bugzilla up-to-date, and many people prefer the
snappier-looking page layout of Red Hat Bugzilla to the default
Mozilla-standard formatting.</para>
<para>URL:
<ulink url="http://bugzilla.redhat.com/bugzilla/">
http://bugzilla.redhat.com/bugzilla/</ulink>
</para>
<para>URL: <ulink
url="http://bugzilla.redhat.com/bugzilla/">http://bugzilla.redhat.com/bugzilla/</ulink></para>
</section>
<section id="variant-fenris" xreflabel="Loki Bugzilla, a.k.a. Fenris">
<title>Loki Bugzilla (Fenris)</title>
<para>Fenris can be found at <ulink
url="http://fenris.lokigames.com/">http://fenris.lokigames.com</ulink>. It is a fork from Bugzilla.</para>
<para>Fenris can be found at
<ulink url="http://fenris.lokigames.com/">
http://fenris.lokigames.com</ulink>
. It is a fork from Bugzilla.</para>
</section>
<section id="variant-issuezilla" xreflabel="Issuezilla">
<title>Issuezilla</title>
<para>Issuezilla is another fork from Bugzilla, and seems nearly
as popular as the Red Hat Bugzilla fork. Some Issuezilla team
members are regular contributors to the Bugzilla mailing
list/newsgroup. Issuezilla is not the primary focus of
bug-tracking at tigris.org, however. Their Java-based
bug-tracker, <xref linkend="variant-scarab" />, is under heavy development
and looks promising!</para>
<para>URL: <ulink url="http://issuezilla.tigris.org/servlets/ProjectHome">http://issuezilla.tigris.org/servlets/ProjectHome</ulink></para>
<para>Issuezilla is another fork from Bugzilla, and seems nearly as
popular as the Red Hat Bugzilla fork. Some Issuezilla team members are
regular contributors to the Bugzilla mailing list/newsgroup. Issuezilla
is not the primary focus of bug-tracking at tigris.org, however. Their
Java-based bug-tracker,
<xref linkend="variant-scarab" />
, is under heavy development and looks promising!</para>
<para>URL:
<ulink url="http://issuezilla.tigris.org/servlets/ProjectHome">
http://issuezilla.tigris.org/servlets/ProjectHome</ulink>
</para>
</section>
<section id="variant-scarab" xreflabel="Scarab, a newfangled Java-based issue tracker">
<section id="variant-scarab"
xreflabel="Scarab, a newfangled Java-based issue tracker">
<title>Scarab</title>
<para>Scarab is a promising new bug-tracking system built using
Java Serlet technology. As of this writing, no source code has
been released as a package, but you can obtain the code from
CVS.
<para>Scarab is a promising new bug-tracking system built using Java
Serlet technology. As of this writing, no source code has been released
as a package, but you can obtain the code from CVS.</para>
<para>URL:
<ulink url="http://scarab.tigris.org/">http://scarab.tigris.org</ulink>
</para>
<para>URL: <ulink url="http://scarab.tigris.org/">http://scarab.tigris.org</ulink></para>
</section>
<section id="variant-perforce" xreflabel="Using Perforce to track bugs">
<title>Perforce SCM</title>
<para>Although Perforce isn't really a bug tracker, it can be used
as such through the <quote>jobs</quote> functionality.</para>
<para><ulink
url="http://www.perforce.com/perforce/technotes/note052.html"></ulink>http://www.perforce.com/perforce/technotes/note052.html</para>
<para>Although Perforce isn't really a bug tracker, it can be used as
such through the
<quote>jobs</quote>
functionality.</para>
<para>
<ulink url="http://www.perforce.com/perforce/technotes/note052.html">
</ulink>
http://www.perforce.com/perforce/technotes/note052.html</para>
</section>
<section id="variant-sourceforge" xreflabel="SourceForge">
<title>SourceForge</title>
<para>SourceForge is more of a way of coordinating geographically
distributed free software and open source projects over the
Internet than strictly a bug tracker, but if you're hunting for
bug-tracking for your open project, it may be just what the
software engineer ordered!</para>
<para>URL: <ulink
url="http://www.sourceforge.net">http://www.sourceforge.net</ulink></para>
</section>
<para>SourceForge is more of a way of coordinating geographically
distributed free software and open source projects over the Internet than
strictly a bug tracker, but if you're hunting for bug-tracking for your
open project, it may be just what the software engineer ordered!</para>
<para>URL:
<ulink url="http://www.sourceforge.net">
http://www.sourceforge.net</ulink>
</para>
</section>
</chapter>
<!-- Keep this comment at the end of the file
......@@ -94,3 +119,4 @@ sgml-shorttag:t
sgml-tag-region-if-active:t
End:
-->
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment