launchpad-dev team mailing list archive

[curtis Hovey <curtis.hovey@xxxxxxxxxxxxx>]

Hi rocket scientists.

At UDS, Laura Czajkowski ask me about how Launchpad could solve the
problem where membership in a team is contingent on a signed code of
conduct. This issue is not a priority for Lp stakeholders, and the
implementation of the feature is complex. I think this feature would be
valuable to several Lp communities and it might be developed in
collaboration.

I have a good knowledge of how teams membership works and how the Ubuntu
Code of Conduct works (and often does not). I want help defining an
clear implementation path that Lp contributors can confidently complete
in few weeks.


Introducing team agreements
===========================

There is a general and a specific bug where team membership is
predicated on an agreement. The agreement might be a code of conduct or
a contributors agreement. User will digitally sign the agreement and Lp
will track the version signed.

    Support for custom code of conduct like forms
    https://bugs.launchpad.net/launchpad/+bug/48551

    Leadership CoC not given to Ubuntu Leaders
    https://bugs.launchpad.net/launchpad/+bug/392976

As a team owner,
I want membership in my team to be predicated on a signed agreement,
so that it is clear what the terms of membership are.

As a team member,
I want to read and sign a team agreement
so that I can contribute to a team.

As a team owner,
I want to upload a new version of an agreement,
so that all current members need to sign it.

As a team member,
I want to see which users have not assigned a new agreement
so that I can contact the user or remove the user from the team.


Open questions
--------------

Can a team have more than one concurrent agreement?

Do new versions always require new signing?

How do team admins know that users need to sign an agreement.

Do users need to assign the agreement /before/ being approved, during
approval, or after approval?

Can I add a team to a team that has an agreement? Who signs?


Example agreements
------------------

    * Code of Conduct
    * Contributor/ownership agreement


Required information to operate
-------------------------------

class CodeOfConduct:
    implements(ICodeOfConduct)

    name = Attribute("The short name of the agreement used for URLs.")
    dispaly_name = Attribute("The name of the agreement used in text.")
    version = Attribute("The version of the agreement.")
    is_current = Attribute("is this the current version of the
        agreement.")
    datereleased = Attribute("The date the version was released.")
    content = Attribute("The content of the signed agreement.")
    active = Attribute("Is this agreement signable.")

The SignedCodeOfConduct will need to know the team and the agreement
that was signed


About Ubuntu's Code of Conduct
------------------------------

The principle block to permitting teams to have agreements is the
lack of Lp infrastructure to support them. The Ubuntu code of conduct is
not extensible, it does not even support revisions to the CoC properly. The
problem is hinted at in one bug.

    CoC implementation needs to be revisited
    https://bugs.launchpad.net/launchpad/+bug/54945

The specific issue is that the Ubuntu CoC is a file on the launchpad
code tree. There can be only one. It is not associated with a team. The
actual Ubuntu agreement is a file in the Launchpad tree. The model class
constructs an instance/version by loading a configuration that is hard
coded in python and the agreement file on disk.

This mechanism is not extensible for team agreements. Teams cannot add
files to the launchpad tree and there is no mechanism to indicate the
version or the team that it applied too.


Refactoring the Ubuntu CoC so that is can be extended
-----------------------------------------------------

Since the Ubuntu CoC is not extensible, we may want to create team
agreements as a separate feature, but solving the existing problem will
ensure the design is general enough to be reused.

    * We want a mechanism where agreements can be uploaded to launchpad
      by users.
    * User can upload a version that supersedes a previous agreement.
      * The agreement may need to invalidate previous signed agreements.
      * The agreement may be a minor revision/correction that is
        existing signed agreements are valid.

Does the Ubuntu CoC need a team to work? Are the signers a member of a
team? Are there advantages to formally making the Ubuntu CoC signers a
team, such as knowing who has signed?


Proposed steps to support team agreements
-----------------------------------------

    * Add db/librarian support to store team agreements.
    * Migrate the Ubuntu agreement into the db/librarian.
    * Create a new model to access the agreement.
    * Update the existing signed agreements to know the team and
      agreement that was signed.
    * Add UI to upload an agreement.
    * Update the UI to retrieve an agreement to support teams
    * Update the UI to upload a signed agreement to support teams
    * Update the membership invite email
    * Add UI to edit an agreement's metadata.
    * Update the add member code to always send invitation emails
      instead of adding the user immediately.
    * Update the team invitation to explain there is an agreement and a
      link to download it, and instructions about how to sign.
    * Update the accept invitation form to also upload the signed
      agreement.
    * Update the team members view to show that the user has signed the
      current agreement.
    * Update the edit membership view to show the state of the signed
      agreement.
    * Add support send an email to members when the current agreement is
      updated.
    * Maybe update the upload signed agreement  form to do better error
      checking and fixing since many user corrupt the data pasting it
      into to form.

-- 
Curtis Hovey
http://launchpad.net/~sinzui

Attachment: signature.asc
Description: OpenPGP digital signature