MoodleDocs - User contributions [en]

Development talk:Tracking Moodle CVS with git

2008-12-18T21:30:49Z

Mudrd8mz: New section: Mass merge

I am currently doing a bit of an overhaul of this page to remove obsolete coigto stuff - dont really see a reason why anyone would use it or want docs for it.--[[User:Dan Poltawski|Dan Poltawski]] 17:04, 1 October 2008 (CDT)
:Great! Thanks! --[[User:Eloy Lafuente (stronk7)|Eloy Lafuente (stronk7)]] 17:05, 1 October 2008 (CDT)

== Mass merge ==

"...If you are applying patches to CVS, you can then use git-cvsexportcommit or plain old patch -p1 filename..."

can anybody please elaborate a bit? Provide and example? TIA --[[User:David Mudrak|David Mudrak]] 15:30, 18 December 2008 (CST)

Development:DML exceptions

2008-11-30T21:23:42Z

Mudrd8mz: /* dml_read_exception */ fix read -> write

{{Moodle_2.0}}In previous versions problems in database calls were ignored by default.

==Overview==
[[Image:Dml_exceptions.png]]

Defined in lib/dmllib.php for now.

===dml_connection_exception===
Thrown when can not connect to database for any reason.

===dml_read_exception===
Problem occurred during reading from database. Originally indicated be returning ''false'' - this value was often confused with ''false'' return value meaning ''not found''.

===dml_write_exception===
Problem occurred during writing to database. Originally indicated be returning ''false''.

==See also==

* [[Development:Exceptions|Exceptions]]: General guidelines for using of exceptions in Moodle 2.0
* [[Development:DML functions|DML functions]]: Where all the functions used to handle DB data. ([[wikipedia:Data_Manipulation_Language|DML]]) are defined.
* [[Development:DDL functions|DDL functions]]: Where all the functions used to handle DB objects ([[wikipedia:Data_Definition_Language|DDL]]) are defined.

Backup and restore FAQ

2008-11-25T13:27:47Z

Mudrd8mz: /* Restoring a course results in broken HTML tags. What can I do? */

==What are the pros and cons of course versus site backups?==

[[Site backup|Site backups]] are recommended in order to have all data saved with the best confidence and the shortest recovery time.

[[Automated course backup|Automated course backups]] are more expensive in terms of time and CPU usage. The recovery time to have your site running again is longer. Course backups are useful for obtaining "fresh" copies of courses to be re-used or distributed individually, however they should never be used as a primary backup system (unless your hosting doesn't allow the preferred site backups).

==What data is not contained in course backups?==

By selecting all the options when setting up the backup you can include almost all the data in the course. However you should be aware of the fact that some things are not backed up:
* Quiz questions are only backed up if at least one question from their category has been added to a quiz.
* Scales are only backed up if they are used by at least one activity.

==The process ends with: "Error: An error occurred deleting old backup data". What should I do?==

This part of the backup (or restore) procedure tries to delete old info, used in previous executions, performing the following tasks:

# Delete old records from "backup_ids" table: Check the table exists, repair it and try again.
# Delete old records from "backup_files" table: Check the table exists, repair it and try again.
# Delete old files from "moodledata/temp/backup": Delete the dir completely and try again.

[[Image:BackupProblem.gif|thumb|Backup error message]]For points 1 & 2, there are various ways of repairing tables, including using MySQL Admin.
For point 3 see below:

The error message states that the "directory not empty" and gives the path to that directory. If you go there with an FTP program you can see what is there and clean up. It could be just some empty subfolders that were leftover. Deleting these has been able to help. One can also delete the dir "moodledata/temp/backup" completely. That can take a bit longer but may solve several problems at once.

==The process ends with: "XML error: not well-formed (invalid token) at line YYYY". What can I do?==

This problem can appear at any point in the restore process. It's caused when the XML parser detects something incorrect in the backup file that prevent correct operation. Usually, it's caused by some "illegal" characters added in the original course due to some copy/paste of text containing them (control characters, or invalid sequences...).

The best method to handle this issue is:

* Unzip the problematic backup file under one empty folder.

* Open the moodle.xml with Firefox. It will show you where (exact char) the problem is happening.

* Edit the moodle.xml file with some UTF8-compatible editor and delete such characters. Save changes.

* Test the moodle.xml file again with Firefox until no error was displayed.

* Zip everything again (all the folder contents but not the folder itself!).

* Restore the course. It should work now.

* Restore still not working? See the next question.

Also, if possible, it's highly recommended to solve those problems in the original course too from Moodle itself. Once "repaired" there, problems will be out if you create new backup files in the future.

==I Still get an XML error. How can I clean the borked XML file?==

In some cases XML backup files may contain characters causing the restore process to abort, even after the steps described in the previous question. In such cases you may want to try the following:

* Download the [http://repository.atlassian.com/atlassian-xml-cleaner/jars/atlassian-xml-cleaner-0.1.jar Atlassian XML Cleaner Utility] from the [http://confluence.atlassian.com/display/JIRA/Removing+invalid+characters+from+XML+backups JIRA Atlassian site].

* Unzip the problematic Moodle backup file under one empty folder. Moodle will create the course file folders as long as the unclean moodle.xml file. Please unzip using the Moodle unzip feature.

* Rename the unclean moodle.xml file to moodle-unclean.xml.

* If you don't have access to your Moodle server's command prompt, using the Moodle zip feature, zip the moodle-unclean.xml file only, download the zip file locally and unzip it. It is very important to download the xml file in zipped format to avoid unwanted character encoding when transferring from an operating system to another.

* Move the downloaded Atlassian XML Cleaner Utility in the same folder where is your moodle-unclean.xml file.

* Issue the following command from the command prompt:

java -jar atlassian-xml-cleaner-0.1.jar moodle-unclean.xml > moodle.xml

* If you launched the utility on your local computer, zip the just created (and hopefully cleaned) moodle.xml file and upload it in the same place from where you downloaded the moodle-unclean.xml file. Once uploaded, unzip it using the Moodle unzip feature.

* Zip everything again (all the folder contents but the folder itself!).

* Restore the course. It should work now.

==What does "Some of your courses weren't saved!!" mean?==

There are three possible causes of this problem:
# Error - this happens when the backup procedure has found an error and so hasn't finished the backup of a particular course. These are "controlled" errors and the scheduled backup continues with the next course.
# Unfinished - this happens when the backup procedure dies without knowing why. When the cron is next executed it detects that the last execution went wrong, and continues skipping the problematic course. A possible solution would be to raise the PHP/Apache limit in your installation (memory, time of execution...). By taking a look to your log tables you should be able to see if the "crash" is happening at exact time intervals (usually a problem with the max_execution_time php's variable), or if there is some exact point were all the courses are breaking (generally internal zip libraries, try to switch to external executables instead).
# Skipped - this happens when a course is unavailable to students and has not been changed in the last month (31 days). This isn't an error situation - it's a feature, especially useful for sites with many unavailable old courses, saving process time.

==How can I restore pre 1.6 non-ISO-8859-1 backups to Moodle 1.6 (Unicode)?==

Any backup files with contents which are not 100% ISO-8859-1 will be a problem to restore to Moodle 1.6 (and upwards) running under Unicode. Instead, please try the following:

# Make a clean install of Moodle 1.5.x (the latest version available)
# Restore all your courses there (they should work if they were working originally)
# Upgrade your site to Moodle 1.6 and run the UTF-8 migration script
# Backup your courses again

This will produce a new set of backup files that will be 100% UTF-8 and you will be able to use them with Moodle 1.6 without any problems.

==Restoring a course results in broken HTML tags. What can I do?==

This problem is due to a [http://bugs.php.net/bug.php?id=45996 PHP bug in libxml2 2.7.1] (the same bug reported with version 2.7.2). All HTML entities, such as >, < and " are removed when a course is restored.

To resolve the problem, you should use a different version of libxml2 such as 2.7.0 or 2.6.32.

At Gentoo servers, you can use

echo ">dev-libs/libxml2-2.6.32" >> /etc/portage/package.mask

==Why are some courses being skipped?==

From 1.6 onwards, course backups automatically skip courses which are unavailable to students and have not been changed in the last month.

==Why does restore stop, rather than completing?==

Attempting to restore a course to an older version of Moodle than the one the course was backed up on can result in the restore process failing to complete. To ensure a successful restore, make sure that the version of Moodle you are restoring the course to is the same, or newer, than the one the course was backed up on.

== See also ==

*Using Moodle [http://moodle.org/mod/forum/view.php?f=128 Backup and Restore forum]
*[http://www.databasejournal.com/features/mysql/article.php/10897_3300511_2 databasejournal.com article on repairing database corruption in MySQL]

Using Moodle forum discussions:
*[http://moodle.org/mod/forum/discuss.php?d=66708 Scheduled backup fails] including possible solution to "An error occurred while copying files".
*[http://moodle.org/mod/forum/discuss.php?d=99338 Restore stops]

[[Category:FAQ]]
[[Category:Backup]]

[[es:FAQ Backup]]
[[pl:Backup FAQ]]
[[fr:FAQ de sauvegarde]]
[[ja:バックアップFAQ]]
[[pt:FAQ sobre cópias de segurança]]

Subcourse module

2008-11-21T21:11:48Z

Mudrd8mz: /* See also */

The module provides very simple yet useful functionality. When added into a course, it behaves as a graded activity. The grade for each student is taken from a final grade in another course. Combined with metacourses, this allows course designers to organize courses into separate units.

The module was created and is currently maintained by [[User:David Mudrak|David Mudrak]].

==Installation==

The module uses PHP exceptions - PHP5 is needed. Use this module at production servers on your own risk - it has not been tested very much yet. On the other hand - you are warmly welcome to install, test and report any problems.

* Moodle 1.9 - checkout [[CVS for Administrators|CVS]] HEAD or download [http://download.moodle.org/plugins/mod/subcourse.zip latest development build]
* Earlier version are not supported

The source codes live in [[CVS for Administrators|CVS]] [http://cvs.moodle.org/contrib/plugins/mod/subcourse/ contrib/plugins/mod/subcourse]. To checkout the module, go to the Moodle mod/ directory and use:
cvs -z3 -d:ext:myusername@cvs.moodle.org:/cvsroot/moodle co -d subcourse contrib/plugins/mod/subcourse

==How to report a bug==

Please, use [[Tracker]]. Subcourse if one of the components in "Non-core contributed modules" project.

==Capabilities==

{{Moodle 1.9}}

{| cellpadding="3" cellspacing="0" border="1"
!Capability
!Description
!Status
|-
|mod/subcourse:begraded
|a user can be graded with the remote final grade
|implemented
|-
|mod/subcourse:fetchgrades
|a user can manually fetch grades from a remote course
|implemented
|}

==See also==
*[http://moodle.org/mod/data/view.php?d=13&rid=1775 Subcourse] in Modules and plugins database page for downloads and more information.

[[Category:Contributed code]]

Subcourse module

2008-11-21T21:11:18Z

Mudrd8mz: /* Installation */

The module provides very simple yet useful functionality. When added into a course, it behaves as a graded activity. The grade for each student is taken from a final grade in another course. Combined with metacourses, this allows course designers to organize courses into separate units.

The module was created and is currently maintained by [[User:David Mudrak|David Mudrak]].

==Installation==

The module uses PHP exceptions - PHP5 is needed. Use this module at production servers on your own risk - it has not been tested very much yet. On the other hand - you are warmly welcome to install, test and report any problems.

* Moodle 1.9 - checkout [[CVS for Administrators|CVS]] HEAD or download [http://download.moodle.org/plugins/mod/subcourse.zip latest development build]
* Earlier version are not supported

The source codes live in [[CVS for Administrators|CVS]] [http://cvs.moodle.org/contrib/plugins/mod/subcourse/ contrib/plugins/mod/subcourse]. To checkout the module, go to the Moodle mod/ directory and use:
cvs -z3 -d:ext:myusername@cvs.moodle.org:/cvsroot/moodle co -d subcourse contrib/plugins/mod/subcourse

==How to report a bug==

Please, use [[Tracker]]. Subcourse if one of the components in "Non-core contributed modules" project.

==Capabilities==

{{Moodle 1.9}}

{| cellpadding="3" cellspacing="0" border="1"
!Capability
!Description
!Status
|-
|mod/subcourse:begraded
|a user can be graded with the remote final grade
|implemented
|-
|mod/subcourse:fetchgrades
|a user can manually fetch grades from a remote course
|implemented
|}

==See also==
*[http://moodle.org/mod/data/view.php?d=13&rid=1775 Subcourse] is a Modules and plugins database page for downloads and more information.

[[Category:Contributed code]]

Development:Language API

2008-11-20T23:22:02Z

Mudrd8mz: more intro info based on the talk page

''This is a draft of a document that should define data structures and API to manipulate Moodle lang files.''

==Motivation==

Moodle uses its own mechanism of translated strings and files storage. Other ways of handling localization files are sometimes requested. Some translators want to use gettext library (which is using .po files), some might want to export Moodle strings into custom format (eg. XML) to translate them with an external tool and import them back to Moodle. The Moodle Language API should enable to write additional plugins of strings and help files storage.

This Language API should provide common interface for all future ''translation tools'' - it does not change the Moodle core itself. Current get_text() implementation is pretty well tuned, caching is supported and it is hopefully debugged. The work on this API started during the developement of several Moodle language tools - langchecker (searches for no-longer used strings in the English pack), langstats (translation progress monitor) and the new version of admin/lang.php interface.

==Language pack URL==

The type of API implementation is selected automatically acording to URL scheme. Currently, only "internal" plugin is supported which represents the traditional way of lang packs handling. Such pack should be referenced as

internal://localhost/full/path/to/the/pack

Other language pack repositories might be references as e.g.:

cvs://username:password@cvs.moodle.org/lang/cs_utf8
gettext://localhost/full/path/to/the/pack
xml://localhost/full/path/to/the/pack

==API usage examples==

Basic usage scenario - get a translated string:

$lang_path = $CFG->dataroot."/lang/".current_language();
$lang_repo = lang_pack_factory("internal://localhost/".$lang_path);
$string = $lang_repo->get_raw_string('identifier', 'module');

Save a customized string translation:

$lang_path = $CFG->dataroot."/lang/".current_language()."_local";
$lang_repo = lang_pack_factory("internal://localhost/".$lang_path);
$lang_repo->save_string('identifier', 'module', $translation);

Commit translation into moodle.org repository:

$lang_repo = lang_pack_factory("cvs://${username}:${password}@cvs.moodle.org/lang/{$langcode}");
$lang_repo->save_module($module, $comment);

==Language API implementations==

[[Image:lang_api_classes.png|thumb|UML diagram of Language API classes]]
The Language API is defined as interface. Every plugin must implement this interface. The internal plugin (representing traditional way) will be implemented first.

===Internal===

The internal plugin is defined as

class lang_pack_internal implements lang_pack_api {...}

The internal plugin will use sevaral classes:

; lang_pack_internal : This represents the whole pack. It is implemented as a directory - e.g. $CFG->dirroot/lang/en_utf8 or $CFG->dataroot/lang/cs_utf8 etc.

; lang_pack_internal_module : represents a single module of a given pack, defines the sub-context of translated texts. It is implemented as a file - e.g. moodle.php or qtype_multichoice.php.

; lang_pack_internal_text : represents a single unit of text (word, sentence or whole page) that can be translated and then used in the UI. It is either one $string[] definition or a help file content.

== See also ==

* [[Development:Places to search for lang strings]].

Development talk:Language API

2008-11-18T12:54:00Z

Mudrd8mz: New section: Re: Performance issue

David, before documenting your proposed solution, please could you add a few words about the problem you are trying to solve. What is it about the current language file system that is not good enough?

Please remember that one of the things the current system does very well is performance. All it has to do is look in some directories then load some PHP files that just define some variables (which any good PHP accelerator will pre-compile for you). Also note that it takes care to only load the files needed by the current page, and only loads each file once, and remembers the results.

So if you are proposing a change, you may be expected to do before and after performance testing before the new system goes into core.

== Re: Performance issue ==

: Tim, thanks for your comments. Yes, I've got performance impact on my mind. What I want to do is to write a very thin wrapper around the current functionality. Therefore, current implementation of get_string() will stay untouched as it is very well tuned and tested. The basic application of the proposed Language API will be the new translation interface which I am currently working on (AJAX based with some additional feature like search, search & replace etc.). Also, some additional tools (e.g. to create a duplicate of a current string in all language packs) are planned.
: When I was writing first concepts of these tools, I had an idea it might be useful to have general language API that is not bind to the current implementation but might enable other developers to write their own implementation. This API should enable to write a simple plugins that deals with translation in other ways (as said - XMl, PO files, direct CVS access etc.).
: So, to summarize - the Language API provides common interface for all future ''translation tools'', not for the Moodle core itself.
: --[[User:David Mudrak|David Mudrak]] 06:54, 18 November 2008 (CST)

File:lang api classes.png

2008-11-18T11:46:38Z

Mudrd8mz: uploaded a new version of "Image:lang api classes.png"

Development:Language API

2008-11-18T11:45:45Z

Mudrd8mz:

''This is a draft of a document that should define data structures and API to manipulate Moodle lang files.''

==Motivation==

Moodle uses its own mechanism of translated strings and files storage. Other ways of handling localization files are sometimes requested. Some translators want to use gettext library (which is using .po files), some might want to export Moodle strings into custom format (eg. XML) to translate them with an external tool and import them back to Moodle. The Moodle Language API should enable to write additional plugins of strings and help files storage.

==Language pack URL==

The type of API implementation is selected automatically acording to URL scheme. Currently, only "internal" plugin is supported which represents the traditional way of lang packs handling. Such pack should be referenced as

internal://localhost/full/path/to/the/pack

Other language pack repositories might be references as e.g.:

cvs://username:password@cvs.moodle.org/lang/cs_utf8
gettext://localhost/full/path/to/the/pack
xml://localhost/full/path/to/the/pack

==API usage examples==

Basic usage scenario - get a translated string:

$lang_path = $CFG->dataroot."/lang/".current_language();
$lang_repo = lang_pack_factory("internal://localhost/".$lang_path);
$string = $lang_repo->get_raw_string('identifier', 'module');

Save a customized string translation:

$lang_path = $CFG->dataroot."/lang/".current_language()."_local";
$lang_repo = lang_pack_factory("internal://localhost/".$lang_path);
$lang_repo->save_string('identifier', 'module', $translation);

Commit translation into moodle.org repository:

$lang_repo = lang_pack_factory("cvs://${username}:${password}@cvs.moodle.org/lang/{$langcode}");
$lang_repo->save_module($module, $comment);

==Language API implementations==

[[Image:lang_api_classes.png|thumb|UML diagram of Language API classes]]
The Language API is defined as interface. Every plugin must implement this interface. The internal plugin (representing traditional way) will be implemented first.

===Internal===

The internal plugin is defined as

class lang_pack_internal implements lang_pack_api {...}

The internal plugin will use sevaral classes:

; lang_pack_internal : This represents the whole pack. It is implemented as a directory - e.g. $CFG->dirroot/lang/en_utf8 or $CFG->dataroot/lang/cs_utf8 etc.

; lang_pack_internal_module : represents a single module of a given pack, defines the sub-context of translated texts. It is implemented as a file - e.g. moodle.php or qtype_multichoice.php.

; lang_pack_internal_text : represents a single unit of text (word, sentence or whole page) that can be translated and then used in the UI. It is either one $string[] definition or a help file content.

== See also ==

* [[Development:Places to search for lang strings]].

How permissions are calculated

2008-11-17T20:02:29Z

Mudrd8mz: Link to the Czech version

{{Roles}}
One of the most frequently asked question is: ''What are my permissions in this context?'' This article will document the function that Moodle uses to answer this question. The article is written for non-programmers as well as programmers, since it describes ''what'' the function does, not ''how''. The ''how'' is complicated. The ''what'' turns out to be relatively simple! If you are a programmer and you insist on reading the code, look for ''has_capability()'' in ''lib/accesslib.php''.

Given a user, a capability, and a context, ''has_capability()'' returns ''true'' if the user is allowed to perform the action controlled by the capability in the given context, and ''false'' otherwise. In calculating the permission, the function considers all of the relevant permission data, which include role definitions, assignments, and overrides.

Moodle never calculates a user's complete set of permissions. To do so would be very costly and also wasteful, since most permissions are never tested. Instead, Moodle calculates permissions only as needed. It does not store the permissions that it calculates, but recalculates them every time it needs to test them. This is why role assignments and overrides no longer have delayed effects, as they did in Moodle 1.7 and 1.8.

Incidentally, you can generate permission tables like the ones in this article using [[The rolesdebug.php roles debugging script]].

==The calculation==

When a user attempts an action that is controlled by a capability, Moodle calls has_capability to see if the action should be permitted. The function is called as follows:

has_capability(CAP,CONTEXT,USER);

where
*CAP is the capability that controls the action (e.g., mod/quiz:attempt)
*CONTEXT is the context in which the capability is being tested
*USER is the user attempting the action

The function returns a true/false result

* ''true'' means the user should be allowed to perform the action
* ''false'' means the user should be prevented from perfoming the action

===Data used by the function===

Suppose USER is about to attempt a quiz (''CAP = mod/quiz:attempt'') in a Module context nested four levels deep within System.

System
|
Category A
|
Subcategory B
|
Course
|
Quiz <--- the user is here

The quiz module will call ''has_capability()'' to see if the user should be allowed to perform this action.

''has_capability()'' considers the following permission data:

* ''Role definitions'' (these are in the System context)
* ''Role assignments'' which may occur in any of the five contexts
* ''Role overrides'' which may occur in any of the contexts except System (there is no concept of override in System).

''has_capability()'' ignores capabilities other than CAP. This simplification lets us view each role or override as if it contains a ''single permission'' having one of the following values

N - Not set
A - Allow
P - Prevent
X - Prohibit

We use the following notation: for a role ''R1'' with permission ''P'', we write ''R1(P)''.

===An example===

In the quiz example, suppose that the user has four roles (''R1'', ''R2'', ''R3'', and ''R4'') and each of the roles has been assigned and overridden as follows:

0 System <---- define R1(A), R2(N), R3(N), R4(P)
| assign R1
|
1 Category A <-------------- overide R1(N) and R4(N)
|
|
2 Subcategory B <---- assign R2 and R3
|
|
3 Course <-------------- override R2(X) and R3(A)
|
|
4 Quiz <---- assign R4 and R1

Note that ''R1'' has been assigned in two different contexts. This is an unusual practice (it is probably someone's error), but since it is legal, we have to consider the possibility that it can happen. In fact this entire example has been contrived to explore the edge cases of the algorithm. In practice, the calculation of permissions is trivial and the function calculates the result you would expect based on common sense and simple mental analysis (for further discussion of this, see [[#A note about the algorithm|A note about the algorithm]] near the end of this article.

===Representing the data in tabular form===

We will set up a table to hold the permission data. The table has
*a column for each context, ordered from highest level (System) to lowest (the context where we want to calculate the permission).
*a row for each context, also listed from highest to lowest.

[[Image:Calculation-3A.png|Empty table]]

The role definitions go in the first row. Put each definition in the column(s) coresponding to the context(s) in which the role is assigned:

[[Image:Calculation-5A.png|Table with assignments added]]

The overrides go in the remaining rows. Each override goes
*in the same column as the role being overridden
*in the row corresponding the context in which the override is made.

To illustrate, let's add just one of the overrides:

[[Image:Calculation-6A.png|Table with just one override]]

R2(X) represents the override to role R2 made in the course context. Let's add the rest of the overrides:

[[Image:Calculation-7A.png|Table with remaining overrides shown]]

The table is now fully populated, and we are ready to calculate the permission.

===The algorithm===

The algorithm follows a path through the table indicated by nodes and arrows in the diagram below and stops as soon as it has a conclusive result.

[[Image:Algorithm_path_through_permission_table_A.png|Algorithm path through permissions data]]

# If there is an X anywhere in the table, STOP. The calculated permission is ''X''
# Go to the START node
# If there is no next node, STOP. The calculated permission is ''P''
# Otherwise, follow the arrow to the next node
#Add the permissions in the node using the numerical equivalents: N = 0, A = +1, P = -1
#* If the sum is positive, STOP. The calculated permission is ''A''
#* If the sum is negative, STOP. The calculated permission is ''P''
#* If the sum is zero, GO TO step 3

Notice that the algorithm stops when either (1) a conclusive result is obtained, or (2) the algorithm reaches the last node without a conclusive result.

===Applying the algorithm to our example===

If we execute the algorithm with the quiz data, we stop at step 1 with a calculated permission of X. That's not very interesting, so let's change the X to a P and see what happens:

[[Image:Calculation-8A.png|Change X to P in permission table]]

Run the algorithm:

*There is No X in the table
*Go to the START node
*Go to the next node
*N + N = 0
*the sum is zero; go to the next node
*A + P = 0
*the sum is zero; go to the next node
*P + A = 0
*the sum is zero; go to the next node
*N + N = 0
*the sum is zero; go to the next node
*N = 0
*the sum is zero; go to the next node
*A = +1
*the sum is positive; STOP. The calculated permission is ''A''

If the calculated permission is ''A'', ''has_capability()'' returns ''true'', and the user is allowed to perform the action.

Had the calculated permission been ''P'' or ''X'', ''has_capability()'' would not immediately return ''false''. Rather, it would test if the user has ''moodle/site:doanything = Allow'' (since this permission trumps all others). The function does this by calling itself:

final result = has_capability(moodle/site:doanything,CONTEXT, USER);

==A note about the algorithm==

Earlier, we said that the algorithm "calculates the result you would expect." But what do we expect? Intuition tells us that permissions closer to the user should carry more weight than more distant permissions. That's why we set up the table the way we did and why the algorithm walks the table in the order that it does. The last column of the table represents the role assignment(s) closest to the user. The second-to-last column represents the role assignent(s) that are next in terms of distance from the user, and so-on. That's why the algorithm considers the columns from right-to-left. Within a column, the algorithm searches upward in order to give higher weight to overrides that are closer to the user. Once again, this matches our intuition about overrides. If there are no overrides in a column (or the overrides are all Not set), the permission in the role definition is used.

==Getting the result you expect==

The calculation is more likely to give "the result you would expect" if you keep your permissions as simple as possible. Therefore, we recommend the following 'rules' for defining and overriding roles. If you understand the description of the calculation above, you should understand why they make sense.

===When defining roles===

... use Allow (A) for things you want the role to be able to do, and use Not set (N) for things you don't care about (which should include most things).

===When overriding permissions===

... leave the permission for every capability as Inherit (N) apart from the few you want to change. For those, use Allow (A) for things you want to allow, and Prevent (P) for things you want to prevent.

===Only use prohibit in special roles===

Prohibit exists to cover extreme scenarios such as the following: Suppose you have a naughty student who is posting inappropriate content in your Moodle site. You need to be able to remove their ability to contribute to public discussions until they have promised not to do it again, but during that time, you cannot completely block them from the resources, quizzes, etc. because they must keep up with their studying. Therefore, you need a way to block their access to specific capabilities e.g. mod/forum:replypost in a way that cannot be overridden. You can do this by creating a special 'Naughty student' role defined with the required permission(s) set to prohibit. Then when you are having problems with a user, you can temporarily assign them this role, either at site level or at course level.

==A practical example==

Suppose that a user, who is assigned the role of Course creator in category B, creates a course (becoming Teacher in the course) and then creates a Lesson within the course. The user is about to edit the lesson (editing lessons is controlled by capability ''mod/lesson:edit''). Here is the permission data:

0 System <---- define Auth user(N), Creator(N), Teacher(A)
| assign Auth user
|
1 Category A
|
|
2 Subcategory B <---- assign Creator
|
|
3 Course <---- assign Teacher
|
|
4 Lesson <---- user attempts to edit lesson

We set up the table and populate it with permission data.

[[Image:Calculation-10A.png|A practical example]]

Since there are no overrides, the table only has data in the first row. The algorithm quickly calculates a permission of ''A'' and returns true. The user is allowed to edit the Lesson!

Now suppose Teacher is overridden in the Lesson context with ''mod/lesson:edit = P''. Then the table changes

[[Image:Calculation-11A.png|A practical example with first override]]

and clearly the user is no longer allowed to edit the Lesson.

But suppose the administrator (or whoever is making the overrides) decided instead to override the ''Creator role'', setting ''mod/lesson:edit = Prevent'' in the Categoy B context:

[[Image:Calculation-12A.png|A practical example with second override]]

Much to everyone's surprise, the user is still allowed to edit the Lesson! If you understood this article, you shouldn't be surprised, and you should be able to explain what happened.

==See also==

*Using Moodle [http://moodle.org/mod/forum/discuss.php?d=90140 Logged in: what role am I?] and [http://moodle.org/mod/forum/discuss.php?d=66782 What happens if a user has multiple roles in a course?] forum discussions.

There is a script that you can use to create tables like the ones in this article. It is very useful for debugging roles-related problems. See [[The rolesdebug.php roles debugging script]].

[[Category:Roles]]

[[fr:Comment les permissions sont calculées ?]]
[[cs:Jak se vypočítávají oprávnění]]

Development:Language API

2008-11-17T16:46:01Z

Mudrd8mz: New page: ''This is a draft of Language API proposal that should define data structures and API to manipulate Moodle lang files.'' [[Image:lang_api_classes.png|thumb|UML diagram of Language API cla...

''This is a draft of Language API proposal that should define data structures and API to manipulate Moodle lang files.''

[[Image:lang_api_classes.png|thumb|UML diagram of Language API classes]]
From the conceptual point of view, the Language API consists of three hierarchical layers. These layers are abstracted as three object classes - see the attached UML diagram.
; language_pack : This represents the whole pack with its own repository, maintainer etc. At the moment, it is implemented as a directory - e.g. $CFG->dirroot/lang/en_utf8 or $CFG->dataroot/lang/cs_utf8 etc. Other implementations should be possible in the future.
* public '''$id''' - lang pack code, e.g. 'en_utf8'
* public '''$name''' - human readable pack name, e.g. 'English with my customizations'
* public '''$location''' - where the lang pack is saved. Currently this will be the full path to the root directory. Might be some general URI format in the future, e.g. filesystem://path/to/the/directory or dbstorage://database.server/user/password or git://git.repository/lang etc.
* public '''load_modules()''' - initializes all modules included in the language pack

; language_module : represents a single module of a given pack, defines the sub-context of translated texts. At the moment, it is implemented as a file - e.g. moodle.php or qtype_multichoice.php. Other implementations should be possible in the future.
; language_string : represents a single unit of text (word, sentence or whole page) that can be translated and then used in the UI. At the moment, this is either one $string[] definition or a help file content.

== See also ==
* [[Development:Places to search for lang strings]].

2008-09-25T13:25:53Z

Mudrd8mz: /* Installation */

2008-08-01T17:26:58Z

Mudrd8mz: /* PostgreSQL performance */ fixed link

Location: ''Administration > Server > Performance''

Moodle can be made to perform very well, at small usage levels or scaling up to many thousands of users. The factors involved in performance are basically the same as for any PHP-based database-driven system. When trying to optimize your server, try to focus on the factor which will make the most difference to the user. For example, if you have relatively more users browsing than accessing the database, look to improve the webserver performance.

==Obtain a baseline benchmark==

Before attempting any optimization, you should obtain a baseline benchmark of the component of the system you are trying to improve. For Linux try [http://lbs.sourceforge.net/ LBS] and for Windows use the Performance Monitor. Once you have quantitative data about how your system is performing currently, you'll be able to determine if the change you have made as has any real impact.

The overall aim of adjustments to improve performance is to use RAM (cacheing) and to reduce disk-based activity. It is especially important to try to eliminate swap file usage as much as you can. If your system starts swapping, this is a sign that you need more RAM.

The '''optimization order preference''' is usually: primary storage (more RAM), secondary storage (faster hard disks/improved hard disk configuration), processor (more and faster).

==Scalability==

Moodle's design (with clear separation of application layers) allows for strongly scalable setups. (Please check the list of [[Large installations|large Moodle installations]].)

Large sites usually separate the web server and database onto separate servers, although for smaller installations this is typically not necessary.

It is possible to load-balance a Moodle installation, for example by using more than one webserver. The separate webservers should query the same database and refer to the same filestore area, but otherwise the separation of the application layers is complete enough to make this kind of clustering feasible. Similarly, the database could be a cluster of servers (e.g. a MySQL cluster), but this is not an easy task and you should seek expert support, e.g. from a Moodle Partner.

'''See also''':
*[http://moodle.org/mod/forum/discuss.php?d=4801 Scalability] forum discussion.
*[http://moodle.org/mod/forum/discuss.php?d=57202 Moodle clustering] forum discussion.
*[http://moodle.org/mod/forum/discuss.php?d=44470 Software load balancing] forum discussion.
*[http://moodle.org/mod/forum/discuss.php?d=49986 TCP load balancing] forum dicsussion.

==Hardware configuration==
'''Note''': The fastest and most effective change that you can make to improve performance is to '''increase the amount of RAM on your web server''' - get as much as possible (eg 4GB). Increasing primary memory will reduce the need for processes to swap to disk and will enable your server to handle more users.
* Better performance is gained by obtaining the best '''processor capability''' you can, i.e. dual or dual core processors. A modern BIOS should allow you to enable hyperthreading, but check if this makes a difference to the overall performance of the processors by using a [http://en.wikipedia.org/wiki/Super_PI CPU benchmarking tool].
* If you can afford them, use '''SCSI hard disks''' instead of SATA drives. SATA drives will increase your system's CPU utilization, whereas SCSI drives have their own integrated processors and come into their own when you have multiple drives. If you must have SATA drives, check that your motherboard and the drives themselves support NCQ (Native Command Queuing).
* Purchase hard disks with a '''low seek time'''. This will improve the overall speed of your system, especially when accessing Moodle's reports.
* Size your '''swap file''' correctly. The general advice is to set it to 4 x physical RAM.
* Use a '''RAID disk system'''. Although there are many different RAID configurations you can create, the following generally works best:
** install a hardware RAID controller (if you can)
** the operating system and swap drive on one set of disks configured as RAID-1.
** Moodle, Web server and Database server on another set of disks configured as RAID-5.
* Use '''gigabit ethernet''' for improved latency and throughput. This is especially important when you have your webserver and database server separated out on different hosts.
* Check the settings on your '''network card'''. You may get an improvement in performance by increasing the use of buffers and transmit/receive descriptors (balance this with processor and memory overheads) and off-loading TCP checksum calculation onto the card instead of the OS.
* Read this [http://moodle.org/mod/forum/discuss.php?d=68579 Case Study] on a server stress test with 300 users.
* See this [http://elearning.sgu.ac.jp/doc/PT/ accompanying report] on network traffic and server loads.

==Operating System==
* You can use [http://en.wikipedia.org/wiki/Linux Linux](recommended), Unix-based, Windows or Mac OS X for the server '''operating system'''. *nix operating systems generally require less memory than Mac OS X or Windows servers for doing the same task as the server is configured with just a shell interface. Additionally Linux does not have licensing fees attached, but can have a big learning curve if you're used to another operating system. If you have a large number of processors running SMP, you may also want to consider using a highly tuned OS such as [http://en.wikipedia.org/wiki/Solaris_Operating_Environment Solaris].
* Check your own OS and '''vendor specific instructions''' for optimization steps.
** For Linux look at the [http://linuxperf.sourceforge.net/ Linux Performance Team] site.
** For Linux investigate the hdparm command, e.g. hdparm -m16 -d1 can be used to enable read/write on multiple sectors and DMA. Mount disks with the async and noatime options.
** For Windows set the sever to be optimized for network applications (Control Panel, Network Connections, LAN connection, Properties, File & Printer Sharing for Microsoft Networks, Properties, Optimization). You can also search the [http://technet.microsoft.com/ Microsoft TechNet site] for optimization documents.

==Web server performance==

Installing [http://www.mozilla.com/en-US/ Firefox] and the [https://addons.mozilla.org/en-US/firefox/addon/1843 firebug] extension will allow you to watch the time it takes for each page component to load. Also, the [https://addons.mozilla.org/en-US/firefox/addon/5369 Yslow] extension will evaluate your page against Yahoo's [http://www.skrenta.com/2007/05/14_rules_for_fast_web_pages_by_1.html 14 rules] ([http://video.yahoo.com/video/play?vid=1040890 video]) for fast loading websites.

===PHP performance===
* You are strongly recommended to use a '''PHP accelerator''' to ease CPU load, such as [http://pecl.php.net/apc APC], [http://www.php-accelerator.co.uk/ PHPA], [http://trac.lighttpd.net/xcache/ Xcache] or [http://eaccelerator.net/ eAccelerator]. (Take care to choose a PHP accelerator that is known to work well with your version of PHP and note that Turck MMCache is [http://turckmmcache.exeprod.com/TheManifestoEnglish no longer maintained] and can cause failures with PHP 5).
* Improvements in read/write performance can be improved by putting the cached PHP pages on a [[TMPFS]] filesystem - but remember that you'll lose the cache contents when there is a power failure or the server is rebooted.
* Performance of PHP is better when installed as an '''Apache/IIS ISAPI module''' (rather than a CGI).
* Also check the '''memory_limit''' in php.ini, reduce it to 16M for Moodle version earlier than 1.7 ([http://moodle.org/mod/forum/discuss.php?d=39656 See this forum discussion]). For Moodle 1.7 or later, it is recommended that the value of memory_limit should be 40M. As of [http://www.php.net/ChangeLog-5.php PHP 5.2.1] the default value for the memory_limit directive is 128M.

===Apache performance===
* If you are using Apache on a Windows server, use the build from [http://www.apachelounge.com Apache Lounge] which is reported to have [http://moodle.org/mod/forum/discuss.php?d=93358 performance and stability improvements] compared to the official Apache download. Note that this is an unofficial build, so may not keep up with official releases.
* Set the '''MaxClients''' directive correctly. Use this formula to help (which uses 80% of available memory to leave room for spare):
MaxClients = Total available memory * 80% / Max memory usage of apache process
:Memory usage of apache process is usually 10MB, so a general rule of thumb is to divide your available memory in megabytes by 10 to get the value of MaxClients. To find the max memory usage of apache processes read the value from the shell command:
#ps -ylC httpd --sort:rss

:If you need to increase the value of '''MaxClients''' beyond 256, you will also need to set the '''ServerLimit''' directive.

:'''Warning''': Do not be tempted to set the value of MaxClients higher than your available memory as your server will consume more RAM than available and start to swap to disk.
* Consider reducing the '''number of modules''' that Apache loads in the httpd.conf file to the minumum necessary to reduce the memory needed.
* Use the '''latest version of Apache''' - Apache 2 has an improved memory model which reduces memory usage further.
* For Unix/Linux systems, consider lowering '''MaxRequestsPerChild''' in httpd.conf to as low as 20-30 (if you set it any lower the overhead of forking begins to outweigh the benefits).
* For a heavily loaded server, consider setting '''KeepAlive Off''' (do this only if your Moodle pages do not contain links to resources or uploaded images) or lowering the '''KeepAliveTimeout''' to between 2 and 5. The default is 15 (seconds) - the higher the value the more server processes will be kept waiting for possibly idle connections. A more accurate value for KeepAliveTimeout is obtained by observing how long it takes your users to download a page. After altering any of the KeepAlive variables, monitor your CPU utilization as there may be an additional overhead in initiating more worker processes/threads.
* As an alternative to using KeepAlive Off, consider setting-up a '''Reverse Proxy server''' infront of the Moodle server to cache HTML files with images. You can then return Apache to using keep-alives on the Moodle server.
* If you do not use a .htaccess file, set the '''AllowOverride''' variable to AllowOverride None to prevent .htaccess lookups.
* Set '''DirectoryIndex''' correctly so as to avoid content-negotiation. Here's an example from a production server:
DirectoryIndex index.php index.html index.htm
* Unless you are doing development work on the server, set '''ExtendedStatus Off''' and disable mod_info as well as mod_status.
* Leave '''HostnamesLookups Off''' (as default) to reduce DNS latency.
* Consider reducing the value of '''TimeOut''' to between 30 to 60 (seconds).
* For the '''Options directive''', avoid Options Multiviews as this performs a directory scan. To reduce disk I/O further use
Options -Indexes FollowSymLinks
*'''Caching''' - Apache can be told to make pages load a lot faster by specifying that the browser should cache some various page elements such as images and reuse them from local memory rather than ask for them again every time a page is requested. How to do this varies slightly between OSes but there are two basic steps:

# Install and enable mod_expires - refer to documentation or man pages
# Add this code to the virtual server config file within the <directory> section for the root directory (or within the .htaccess file if AllowOverrides is On):
<IfModule mod_expires.c>
ExpiresActive On
ExpiresDefault "access plus 1 seconds"
ExpiresByType text/html "access plus 1 seconds"
ExpiresByType image/gif "access plus 1 week"
ExpiresByType image/jpeg "access plus 1 week"
ExpiresByType image/png "access plus 1 week"
ExpiresByType text/css "access plus 1 week"
ExpiresByType text/javascript "access plus 1 week"
ExpiresByType application/x-javascript "access plus 1 week"
ExpiresByType text/xml "access plus 1 seconds"
</IfModule>

The effect is to make everything stay in the cache except HTML and XML, which change dynamically. It's possible to gain a several hundred percent decrease in load times this way. Adjust the cache times according to how often your images etc change.

More info: [http://www.metaskills.net/blog/heuristics/sysadmin/how-to-control-browser-caching-with-apache-2 www.metaskills.net]

===IIS performance===
All alter this location in the registry:
HKLM\SYSTEM\CurrentControlSet\Services\Inetinfo\Parameters\
* The equivalent to KeepAliveTimeout is '''ListenBackLog''' (IIS - registry location is HKLM\ SYSTEM\ CurrentControlSet\ Services\ Inetinfo\ Parameters). Set this to between 2 to 5.
*Change the '''MemCacheSize''' value to adjust the amount of memory (Mb) that IIS will use for its file cache (50% of available memory by default).
*Change the '''MaxCachedFileSize''' to adjust the maximum size of a file cached in the file cache in bytes. Default is 262,144 (256K).
*Create a new DWORD called '''ObjectCacheTTL''' to change the length of time (in milliseconds) that objects in the cache are held in memory. Default is 30,000 milliseconds (30 seconds).

===Lighttpd performance===
You can increase web server performance by using the '''light-weight webserver''' [http://www.lighttpd.net/ lighttpd] in combination with PHP in fastCGI-mode. Lighttpd has a lower memory consumption than Apache - typically 10M for each process. See this [[lighttpd | MoodleDocs Lighttpd page]] for configuration and administration links.

==Database performance==

Moodle contains a script which will display some key database performance statistics from the [http://phplens.com/lens/adodb/docs-perf.htm ADOdb performance monitor]. Run the script in your browser as in the following example:

http://www.mymoodle.com/admin/dbperformance.php

Use the data displayed as a guide to tune and improve the performance of your database server.

===MySQL performance===

The following are MySQL specific settings which can be adjusted for better performance in your my.cnf (my.ini in Windows). The file contains a list of settings and their values. To see the current values use these commands
SHOW STATUS;
SHOW VARIABLES;
'''Important''': You must make backups of your database before attempting to change any MySQL server configuration. After any change to the my.cnf, restart mysqld.
* Enable the '''query cache''' with
query_cache_type = 1.
For most Moodle installs, set the following:
query_cache_size = 36M
query_cache_min_res_unit = 2K.
The query cache will improve performance if you are doing few updates on the database.
* Set the '''table cache''' correctly. For Moodle 1.6 set
table_cache = 256
(min), and for Moodle 1.7 set
table_cache = 512
(min). The table cache is used by all threads (connections), so monitor the value of opened_tables to further adjust - if opened_tables > 3 * table_cache then increase table_cache upto your OS limit. Note also that the figure for table_cache will also change depending on the number of modules and plugins you have installed. Find the number for your server by executing the mysql statement below. Look at the number returned and set table_cache to this value.
mysql>SELECT COUNT(table_name) FROM information_schema.tables WHERE table_schema='yourmoodledbname';
* Set the '''thread cache''' correctly. Adjust the value so that your thread cache utilization is as close to 100% as possible by this formula:
thread cache utilization (%) = (threads_created / connections) * 100
* The '''key buffer''' can improve the access speed to Moodle's SELECT queries. The correct size depends on the size of the index files (.myi) and in Moodle 1.6 or later (without any additional modules and plugins), the recommendation for this value is key_buffer_size = 32M. Ideally you want the database to be reading once from the disk for every 100 requests so monitor that the value is suitable for your install by adjusting the value of key_buffer_size so that the following formulas are true:
key_read / key_read_requests < 0.01
key_write / key_write_requests <= 1.0
* Set the '''maximum number of connections''' so that your users will not see a "Too many connections" message. Be careful that this may have an impact on the total memory used. MySQL connections usually last for milliseconds, so it is unusual even for a heavily loaded server for this value to be over 200.
* Manage '''high burst activity'''. If your Moodle install uses a lot of quizzes and you are experiencing performance problems (check by monitoring the value of threads_connected - it should not be rising) consider increasing the value of back_log.
* '''Optimize your tables weekly and after upgrading Moodle'''. It is good practice to also optimize your tables after performing a large data deletion exercise, e.g. at the end of your semester or academic year. This will ensure that index files are up to date. Backup your database first and then use:
mysql>CHECK TABLE mdl_tablename;
mysql>OPTIMIZE TABLE mdl_tablename;
:The common tables in Moodle to check are mdl_course_sections, mdl_forum_posts, mdl_log and mdl_sessions (if using dbsessions). Any errors need to be corrected using REPAIR TABLE (see the [http://dev.mysql.com/doc/refman/5.0/en/repair-table.html MySQL manual] and this [http://moodle.org/mod/forum/discuss.php?d=58208#p279638 forum script]).
* '''Maintain the key distribution'''. Every month or so it is a good idea to stop the mysql server and run these myisamchk commands.
#myisamchk -a -S /pathtomysql/data/moodledir/*.MYI
:'''Warning''': You must stop the mysql database process (mysqld) before running any myisamchk command. If you do not, you risk data loss.
* Reduce the number of '''temporary tables saved to disk'''. Check this with the created_tmp_disk_tables value. If this is relatively large (>5%) increase tmp_table_size until you see a reduction. Note that this will have an impact on RAM usage.
* Moodle's tables are in the MyISAM format, so '''turn InnoDB off''' as there is no performance gain. Add <code>skip-innodb</code> to your <code>my.cnf</code> file. If you must use InnoDB, you'll have to convert all of Moodle's tables. To do this run the innodb script:

http://www.mymoodle.com/admin/innodb.php

:See also [http://moodle.org/mod/forum/discuss.php?d=12961 this forum discussion] which looks at the MyISAM vs InnoDB options.

===PostgreSQL performance===

See [http://moodle.org/mod/forum/discuss.php?d=68558 Tuning PostgreSQL] thread

===Other database performance links===
* Consider using a '''distributed cacheing system''' like [http://en.wikipedia.org/wiki/Memcached memcached] but note that memcached does not have any security features so it should be used behind a firewall.
* Consider using PostgreSQL. See [[Arguments in favour of PostgreSQL]] and [http://moodle.org/mod/forum/discuss.php?d=49195 how to migrate from MySQL to PostgreSQL] (forum discussion).
* [[Increasing the database connection lifetime | Try increasing the database connection lifetime]]
* [http://dev.mysql.com/doc/refman/5.0/en/server-parameters.html General advice on tuning MySQL parameters] (advice from the MySQL manual)
* [http://www.mysqlperformanceblog.com/2007/11/01/innodb-performance-optimization-basics/ InnoDB performance optimization] taken from the [http://www.mysqlperformanceblog.com/ MySQL performance blog] site.

==Moodle Admin settings==
* In Moodle 1.7 or later, set the '''Cache type''' for your server: Site Admin -> Server -> Performance -> Cache type. There are several options available.
:*If you do not have eaccelerator or mmemcached installed, choose "internal" (which makes use of the record/internal cache - see the next bullet point).
:* If you have a single server and have compiled '''eaccelerator with shared memory support''', set the cache type to the eaccelerator option.
:* If you have a '''separate memcached server''', set the cache type to memcached and enter a csv list of server IP addresses.
* Enable the '''record/internal cache''': Site Admin -> Server -> Performance -> Record cache = True. Set the maximum amount of memory allocated to the cache in the Int Cache Max box. This will enable a primary cache for database records, without using any database engine cache, e.g. MySQL/PostgreSQL cache. See [http://tracker.moodle.org/browse/MDL-7196 this Tracker entry] for a full discussion.
* Enable the '''language cache'''.
* Large log files can cause overall performance to degrade over time. If you observe that the site has gradually got slower loading pages in the browser, '''reduce your Log life time''' setting (Admin/Server/Cleanup).
* Performance can be greatly improved by allowing Moodle to use the system '''zip/unzip''' commands (rather than PHP-based zip libraries) - visit Admin/Server/System Paths and enter the path to the relevant executables. (Similarly, filling in the path to '''du''' will improve Moodle's speed at listing directory contents.)
* Note that using '''secure web connections''' ('''https''' rather than '''http''') carries a higher processing burden, both for the webserver and the client - particularly because cacheing cannot be used as effectively, so the number of file requests is likely to increase dramatically. For this reason using https for all Moodle pages is not recommended. You can enable https just for the login screen, simply from Moodle's config page.
* Check your '''filters'''. Having too many filters active can have serious effects on server load, especially on lower-end systems. The number of active filters has a direct effect on the perceived latency of your site; that is the time taken for each page impression.
* Enable the '''text cache''' but do not "Filter all strings" unless you have a specific need. If in doubt profile the performance, and see how your changes affect the processing time.
* Check your '''anti-virus''' measures on the server. Although they are useful for preventing security holes being exploited, some "On-Demand" scanners can affect performance by scanning page content (word, ppt files etc).
* If there are performance problems loading course pages, check the '''Resource module settings'''. The setting resource_filterexternalpages is known to slow-down course pages and should be set to 'No' for better performance.
* Check your '''forum settings'''. To improve performance set forum_trackreadposts = No and forum_usermarksread = Yes (this will impact on the convenience of your users' forum experience). Also consider setting the time of the day when old posts are cleared from the read table (forum_cleanreadtime) to when your site is less busy.

==Performance of different Moodle modules==

Moodle's activity modules, filters, and other plugins can be activated/deactivated. If necessary, you may wish to deactivate some features (such as chat) if not required - but this isn't necessary. Some notes on the performance of certain modules:

* The '''Chat''' module is [http://moodle.org/mod/forum/discuss.php?d=37979&parent=175079 said] to be a hog in terms of frequent HTTP requests to the main server. This can be reduced by setting the module to use ''Streamed'' updates, or, if you're using a Unix-based webserver, by running the chat in daemon mode. When using the Chat module use the configuration settings to tune for your expected load. Pay particular attention to the ''chat_old_ping'' and ''chat_refresh'' parameters as these can have greatest impact on server load.
* The '''Quiz''' module is known to stretch database performance. Try to optimise your database server by tuning. See [http://moodle.org/mod/forum/discuss.php?d=25616&parent=120770 for a brief report on performance for 55 students simultaneously using quizzes]
** See this Case Study for an extensive server stress test with 300 quiz users.[http://moodle.org/mod/forum/discuss.php?d=68579] And this accompanying report on network traffic and server loads. [http://elearning.sgu.ac.jp/doc/PT/]
* The Moodle '''Cron''' task is triggered by calling the script ''cron.php''. If this is called over HTTP (e.g. using wget or curl) it can take a large amount of memory on large installations. If it is called by directly invoking the php command (e.g. ''php -f /path/to/moodle/directory/admin/cron.php'') efficiency can be much improved.

==See also==

*[[Performance FAQ]]
*Using Moodle [http://moodle.org/mod/forum/view.php?f=94 Hardware and Performance forum]

There have been a lot of discussions on moodle.org about performance, here are some of the more interesting and (potentially) useful ones:

* [http://moodle.org/mod/forum/discuss.php?d=83057 Performance woes!]
* [http://moodle.org/mod/forum/discuss.php?d=57028 Performance perspectives - a little script]
* [http://moodle.org/mod/forum/discuss.php?d=88927 Comments on planned server hardware]

[[Category:Performance]]

[[fr:Performance]]
[[ja:パフォーマンス]]
[[pl:Wydajność]]

Performance

File:cord002-totalcostcalc.png

2008-07-28T22:55:55Z

Mudrd8mz: