Public bug reported:

[Availability]
The package gweather-locations is already in Ubuntu tenacious(universe).
The package gweather-locations build for the architectures it is designed to 
work on.
It currently builds and works for architectures: amd64 arm64 armhf ppc64el 
riscv64 s390x
Link to package https://launchpad.net/ubuntu/+source/gweather-locations

[Rationale]

# -------- Demand
RULE: There must be a certain level of demand for the package

The package gweather-locations is required in Ubuntu main because:
  - It is a new runtime dependency of libgweather4 (which is in main)
  - Debian libgweather 4.6.0+ depends on it (Ubuntu is at 4.4.4, Debian is at 
4.6.0)
  - When Ubuntu syncs to newer Debian version, this must be in main
  - Required for core GNOME weather functionality


# -------- Alternatives
RULE: Sometimes there are other/better ways, often are achieved by using a
RULE: library with similar functionality that is more commonly used and
RULE: thereby already in main or a better candidate to promote.
RULE: Reducing the set of supported software in Ubuntu helps to focus on the
RULE: right things, otherwise Ubuntu developers will be consumed by updating
RULE: many variations of the same - wasting valuable time that could be better
RULE: spent elsewhere.
RULE: If there are other packages in the archive that are close, but unable to
RULE: address the problem you might spend some time explaining what exists and
RULE: why it isn't a sufficient alternative.

There is no other/better way to solve this that is already in main

# -------- Prior-art
RULE: If the package is in main in other releases (use rmadison to check),
RULE: and the existing MIR and package content is still applicable and not
RULE: outdated relative to what you want to add, then please help us to
RULE: keep the discussion, argument and audit trail together.
RULE: To do so just add a new per-release tasks instead of creating a new MIR.
RULE: Otherwise - if the existing former case was way too different, continue
RULE: preparing this new MIR and please reference to the previous MIR.
RULE: This suggestion of per release tasks is valid in both directions.
RULE: For example forward when something was MIRed in 24.10 and 25.04 but got
RULE: demoted in 25.10 - and shall come back to 26.04 please add a task to
RULE: the existing MIR instead of creating a new one. Of course the reasons for
RULE: demotion in 25.10 will be important for this case.
RULE: And for example backwards, when something was MIRed for 24.04 onward,
RULE: but later is also needed in older releases like 22.04. In that
RULE: case you likely want to ensure via SRUs that things are up to date anyway
RULE: and yet again -  if the content, reasoning and outside factors are not
RULE: vastly different - you'd be expected to add per-release-tasks to the
RULE: existing MIR case which makes it easier for reporter and reviewer alike.

This is the first time package will be in main

# -------- Main-vs-universe
RULE: You truly need to understand the difference between main and universe
RULE: in general and in the context of changed rules (build-depends) and
RULE: constraints (Ubuntu Pro made it less of a difference in many cases).
RULE: We have seen requests that were mostly based on old "I said supported (a
RULE: weakly defined term to begin with) in a contract, so it has to be in main"
RULE: feelings, but with sometimes no true reason - neither technically nor
RULE: helping the user base of Ubuntu. Hence we need to ask for that clearly.

The binary packages gweather-locations needs to be in main to support
libgweather4

# -------- Deadline
RULE: Reviews will take some time. Also the potential extra work out of review
RULE: feedback from either MIR-team and/or security-team will take time.
RULE: For better prioritization it is quite helpful to clearly state the
RULE: target release and set a milestone to the bug task.
RULE: When doing so do not describe what you "wish" or "would like to have".
RULE: Only milestones that are sufficiently well-founded and related to
RULE: major releases will be considered

It would be great and useful to community/processes to have the
package before Ubuntu syncs libgweather 4.6.0+ in Ubuntu main 
,but there is no definitive deadline.

[Security]

# -------- CVE-history
RULE: The security history and the current state of security issues in the
RULE: package must allow us to support the package for at least 9 months (120
RULE: for LTS+ESM support) without exposing its users to an inappropriate level
RULE: of security risks. This requires checking of several things:
RULE:   - Search in the National Vulnerability Database using the PKG as keyword
RULE:     https://cve.mitre.org/cve/search_cve_list.html
RULE:   - check OSS security mailing list (feed into search engine
RULE:     'site:www.openwall.com/lists/oss-security <pkgname>')
RULE:   - Ubuntu CVE Tracker
RULE:     https://ubuntu.com/security/cve?package=<source-package-name>
RULE:   - Debian Security Tracker
RULE:     
https://security-tracker.debian.org/tracker/source-package/<source-package-name>

No CVEs/security issues in this software in the past


# -------- Security-sensitive-behavior
RULE: - Check for security relevant binaries, services and behavior.
RULE:   If any are present, this requires a more in-depth security review.
RULE:   Demonstrating that common isolation/risk-mitigation patterns are used
RULE:   will help to raise confidence. For example a service running as root
RULE:   open to the network will need to be considered very carefully. The same
RULE:   service dropping the root permissions after initial initialization,
RULE:   using various systemd isolation features and having a default active
RULE:   apparmor profile is much less concerning and can speed up acceptance.
RULE:   This helps Ubuntu, but you are encouraged to consider working with
RULE:   Debian and upstream to get those security features used at wide scale.
RULE: - It might be impossible for the submitting team to check this perfectly
RULE:   (the security team will), but you should be aware that deprecated
RULE:   security algorithms like 3DES or TLS/SSL 1.1 are not acceptable.
RULE:   If you think a package might do that it would be great to provide a
RULE:   hint for the security team like "Package may use deprecated crypto"
RULE:   and provide the details you have about that.

No security-sensitive behaviour
 - no `suid` or `sgid` binaries
 - no executables in `/sbin` and `/usr/sbin`
 - Package does not install services, timers or recurring jobs
 - Packages does not open privileged ports (ports < 1024).
 - Package does not expose any external endpoints

# -------- Deprecated-crypto
RULE: The package should not use deprecated security algorithms like 3DES or
RULE: TLS/SSL 1.1. The security team is the one responsible to check this,
RULE: but if you happen to spot something it helps to provide a hint.
RULE: Provide whatever made you suspicious as details along that statement.
RULE: Or remove the following lines entirely if you did not spot anything.

No deprecated cryptographic algorithms(Data-only package)

[Quality assurance - function/usage]
RULE: - After installing the package it must be possible to make it working with
RULE:   a reasonable effort of configuration and documentation reading.

The package works well right after install

[Quality assurance - maintenance]
RULE: - To support a package, we must be reasonably convinced that upstream
RULE:   supports and cares for the package.
RULE: - The status of important bugs in Debian, Ubuntu and upstream's bug
RULE:   tracking systems must be evaluated. Important bugs must be pointed out
RULE:   and discussed in the MIR report.

The package is maintained well in Debian/GNOME
not have too many, long-term & critical, open bugs
  - Upstream: https://gitlab.gnome.org/GNOME/gweather-locations
  - Debian maintainers: Debian GNOME Maintainers
  - No critical open bugs reported


# -------- Exotic-hardware
RULE: This is about confidence to be able to maintain the package, therefore
RULE: any option (the examples or anything else you add) is "valid", but it
RULE: depends on the case if that is then considered sufficient.
RULE: The following examples are in descending order in regard to how "ok" they
RULE: likely will be.

The package does not deal with exotic hardware we cannot support

[Quality assurance - testing]

# -------- Build-time-tests
RULE: - The package must include a non-trivial test suite
RULE:   - it should run at package build and fail the build if broken

The package does not run a test at build time because:
  - It is a data-only package (location database files)
  - No executable code to test
  - Upstream provides no tests for data


# -------- Autopkgtests
RULE:   - The package should, but is not required to, also contain
RULE:     non-trivial autopkgtest(s).

The package does not run an autopkgtest because:
  - It is a data-only package with no executable code
  - Testing occurs at the libgweather level (which uses this data)
  - The data integrity is maintained through packaging (file hashes)

# -------- Failing-tests
RULE: - existing but failing tests that shall be handled as "ok to fail"
RULE:   need to be explained along the test logs below

The package does have not failing autopkgtests right now((no tests
present)


# -------- Untestable-packages
RULE: - If no build tests nor autopkgtests are included, and/or if the package
RULE:   requires specific hardware to perform testing, the subscribed team
RULE:   must provide a written test plan in a comment to the MIR bug, and
RULE:   commit to running that test either at each upload of the package or
RULE:   at least once each release cycle. In the comment to the MIR bug,
RULE:   please link to the codebase of these tests (scripts or doc of manual
RULE:   steps) and attach a full log of these test runs. This is meant to
RULE:   assess their validity (e.g. not just superficial).
RULE:   If possible such things should stay in universe. Sometimes that is
RULE:   impossible due to the way how features/plugins/dependencies work
RULE:   but if you are going to ask for promotion of something untestable
RULE:   please outline why it couldn't provide its value (e.g. by splitting
RULE:   binaries) to users from universe.
RULE:   This is a balance that is hard to strike well, the request is that all
RULE:   options have been exploited before giving up. Look for more details
RULE:   and backgrounds https://github.com/canonical/ubuntu-mir/issues/30
RULE:   Just like in the SRU process it is worth to understand what the
RULE:   consequences a regression (due to a test miss) would be. Therefore
RULE:   if being untestable we ask to outline what consequences this would
RULE:   have for the given package. And let us be honest, even if you can
RULE:   test you are never sure you will be able to catch all potential
RULE:   regressions. So this is mostly to force self-awareness of the owning
RULE:   team than to make a decision on.

The package can not be well tested at build or autopkgtest time
because:
  - It contains only location database files, no executables
  - Functional testing occurs through libgweather's autopkgtests
  - Data package is verified through:
    * File integrity checks during package build
    * Integration testing via dependent packages (libgweather4)
    * Lintian checks


# -------- Micro-libraries
RULE: - In some cases a solution that is about to be promoted consists of
RULE:   several very small libraries and one actual application uniting them
RULE:   to achieve something useful. This is rather common in the go/rust space.
RULE:   In that case often these micro-libs on their own can and should only
RULE:   provide low level unit-tests. But more complex autopkgtests make no
RULE:   sense on that level. Therefore in those cases one might want to test on
RULE:   the solution level.
RULE:   - Process wise MIR-requesting teams can ask (on the bug) for this
RULE:     special case to apply for a given case, which reduces the test
RULE:     constraints on the micro libraries but in return increases the
RULE:     requirements for the test of the actual app/solution.
RULE:   - Since this might promote micro-lib packages to main with less than
RULE:     the common level of QA any further MIRed program using them will have
RULE:     to provide the same amount of increased testing.


[Quality assurance - packaging]

# -------- Upstream-watch
RULE: - The package uses a debian/watch or debian/upstream/metadata file
RULE:   whenever possible. The second option is the alternative for packages
RULE:   maintained with git-buildpackage. Consider whether that's
RULE:   still true at the time of reporting your MIR. In cases where this is
RULE:   not possible (e.g. native packages), the package should either provide
RULE:   a debian/README.source file or a debian/watch file (with comments only)
RULE:   providing clear instructions on how to generate the source tar file.
RULE:   For clarity the TODOs below refer as "upstream watch file" to any
RULE:   solution similar to the alternatives above which must be present in the
RULE:   package so tools can detect and fetch new upstream releases.

A mechanism to detect and fetch new upstream versions is present and
works


# -------- Maintainer
RULE: - The package should define the correct "Maintainer:" field in
RULE:   debian/control. This needs to be updated, using `update-maintainer`
RULE:   whenever any Ubuntu delta is applied to the package, as suggested by
RULE:   dpkg (LP: #1951988)

debian/control defines a correct Maintainer field


# -------- Lintian
RULE: - It is often useful to run `lintian --pedantic` on the package to spot
RULE:   the most common packaging issues in advance
RULE: - Non-obvious or non-properly commented lintian overrides should be
RULE:   explained

This package does not yield massive lintian Warnings, Errors
- Please link to a recent build log of the package : 
https://launchpad.net/ubuntu/+source/gweather-locations/2026.2-2/+build/33919610

# -------- Obsolete-deps
RULE: - The package should not rely on obsolete or about to be demoted packages.
RULE:   That currently includes package dependencies on Python2 (without
RULE:   providing Python3 packages), and packages depending on GTK2.

This package does not rely on obsolete or about to be demoted packages.
This package has no python2 or GTK2 dependencies


# -------- Debconf
RULE: - Debconf questions should not bother the default user too much

The package will not ask debconf questions


# -------- Packaging-complexity
RULE:  - The source packaging (in debian/) should be reasonably easy to
RULE:   understand and maintain.

Packaging and build is easy

[UI standards]

# -------- Translation
RULE: - End-user facing applications must support translation/intl.
RULE:   Non-end-user applications (libraries, daemons, CLI tools) are exempt.

Application is not end-user facing (does not need translation)


# -------- Desktop-file
RULE: - End-user GUI applications should ship a standard conformant desktop 
file.

Not applicable

[Dependencies]
RULE: - In case of alternatives, the first alternative must be in main.
RULE:   Depends: concrete-package-in-main | metapackage
RULE: - Build(-only) dependencies can be in universe
RULE: - If there are further dependencies they need a separate MIR discussion
RULE:   (this can be a separate bug or another task on the main MIR bug)

No runtime dependencies to check
  - Data-only package
  - Used as runtime dependency by libgweather4

[Standards compliance]

# -------- FHS-and-policy
RULE: - Major violations should be documented and justified.
RULE:   - FHS: https://refspecs.linuxfoundation.org/fhs.shtml
RULE:   - Debian Policy: https://www.debian.org/doc/debian-policy/

This package correctly follows FHS and Debian Policy


# -------- License-longevity
RULE: - The package's license must remain compatible with Ubuntu main for the
RULE:   full support lifetime of the release (including ESM where relevant).
RULE:   Consider whether the license could expire, time out, or otherwise change
RULE:   after promotion. Examples of concerns include time-limited patent 
grants,
RULE:   licenses tied to a specific upstream entity or contract, dual-licensed
RULE:   code where the permissive branch could be withdrawn, or terms that only
RULE:   apply to the current upstream version.
RULE:   If you suspect any of the above may apply, flag it explicitly so the MIR
RULE:   team can weigh the long-term cost before promotion.

Based on a reasonable review of information available at the time of
this report, no expiry, time-limited grants, or obvious legal
encumbrances have been identified that would be expected to affect
promotion

[Maintenance/Owner]

# -------- Owning-team
RULE: The package must have an acceptable level of maintenance corresponding
RULE: to its complexity:
RULE: - All packages must have a designated "owning" team, regardless of
RULE:   complexity. Only a selected set of Launchpad teams can own a package
RULE:   in main, you can find this list here:
RULE:   https://git.launchpad.net/ubuntu-archive-tools/tree/lputils.py#n46
RULE:   This requirement of an owning-team comes in two aspects:
RULE:   - A case needs to have a team essentially saying "yes we will own that"
RULE:     to enter the MIR process. Usually that is implied by team members
RULE:     filing MIR requests having the backup by their management for the
RULE:     long term commitment this implies.
RULE:     - A community driven MIR request might be filed to show the use case,
RULE:       but then, as a first step, needs to get a team agreeing to own
RULE:       it before the case can be processed further.
RULE:       If unsure which teams to consider have a look at the current mapping
RULE:       http://reqorts.qa.ubuntu.com/reports/m-r-package-team-mapping.html
RULE:       In that case (you are not a representative of the team who will
RULE:       gain the long term committment to this) please ask a representative
RULE:       of that team to comment on the bug acknowledging that they are ok to
RULE:       own it.
RULE:   - The package needs a bug subscriber before it can be promoted to main.
RULE:     Strictly speaking that subscription can therefore wait until the
RULE:     moment of the actual promotion by an archive admin. But it is
RULE:     strongly recommended to subscribe early, as the owning team will get
RULE:     a preview of the to-be-expected incoming bugs later on.
RULE: - Simple packages (e.g. language bindings, simple Perl modules, small
RULE:   command-line programs, etc.) might not need very much maintenance
RULE:   effort, and if they are maintained well in Debian we can just keep them
RULE:   synced. They still need a subscribing team to handle bugs, FTBFS and
RULE:   tests
RULE: - More complex packages will usually need a developer or team of
RULE:   developers paying attention to their bugs, whether that be in Ubuntu
RULE:   or elsewhere (often Debian). Packages that deliver major new headline
RULE:   features in Ubuntu need to have commitment from Ubuntu developers
RULE:   willing to spend substantial time on them.

I Suggest the owning team to be ubuntu-gnome(or appropriate GNOME team)

The future owning team is already subscribed to the package


# -------- Static-builds
RULE: - Responsibilities implied by static builds promoted to main, which is
RULE:   not a recommended but a common case with golang and rust packages.
RULE:   - the security team will track CVEs for all vendored/embedded sources 
in main
RULE:   - the security team will provide updates to main for all `golang-*-dev`
RULE:     packages
RULE:   - the security team will provide updates to main for non-vendored
RULE:     dependencies as per normal procedures (including e.g.,
RULE:     sponsoring/coordinating uploads from teams/upstream projects, etc)
RULE:   - the security team will perform no-change-rebuilds for all packages
RULE:     listing an CVE-fixed package as Built-Using and coordinate testing
RULE:     with the owning teams responsible for the rebuilt packages
RULE:   - for packages that build using any `golang-*-dev` packages:
RULE:     - the owning team must state their commitment to test
RULE:       no-change-rebuilds triggered by a dependent library/compiler and to
RULE:       fix any issues found for the lifetime of the release (including ESM
RULE:       when included)
RULE:     - the owning team must provide timely testing of no-change-rebuilds
RULE:       from the security team, fixing the rebuilt package as necessary
RULE:   - for packages that build with approved vendored code:
RULE:     - the owning team must state their commitment to provide updates to
RULE:       the security team for any affected vendored code for the lifetime of
RULE:       the release (including ESM when included)
RULE:     - the security team will alert the owning team of issues that may
RULE:       affect their vendored code
RULE:     - the owning team will provide timely, high quality updates for the
RULE:       security team to sponsor to fix issues in the affected vendored code
RULE:     - the owning team will use a minimal set of vendored code (e.g., Rust
RULE:       packages are unlikely to need `*_win` crates to build)
RULE:     - if subsequent uploads add new vendored components or dependencies
RULE:       these have to be reviewed and agreed by the security team.
RULE:     - Such updates in the project might be trivial, but imply that a
RULE:       dependency for e.g. a CVE fix will be moved to a new major version.
RULE:       Being vendored that does gladly at least not imply incompatibility
RULE:       issues with other packages or the SRU policy. But it might happen
RULE:       that this triggers either:
RULE:       a) The need to adapt the current version of the main package and/or
RULE:          other vendored dependencies to work with the new dependency
RULE:       b) The need to backport the fix in the dependency as the main
RULE:          package will functionally only work well with the older version
RULE:       c) The need to backport the fix in the dependency, as it would imply
RULE:          requiring a newer toolchain to be buildable that isn't available
RULE:          in the target release.
RULE: - The rust ecosystem currently isn't yet considered stable enough for
RULE:   classic lib dependencies and transitions in main; therefore the
RULE:   expectation for those packages is to vendor (and own/test) all
RULE:   dependencies (except those provided by the rust runtime itself).
RULE:   This implies that all the rules for vendored builds always
RULE:   apply to them. In addition:
RULE:   - The rules and checks for rust based packages are preliminary and might
RULE:     change over time as the ecosystem matures and while
RULE:     processing the first few rust based packages.
RULE:   - It is expected rust builds will use dh-cargo so that a later switch
RULE:     to non vendored dependencies isn't too complex (e.g. it is likely
RULE:     that over time more common libs shall become stable and then archive
RULE:     packages will be used to build).
RULE:   - The tooling to get a Cargo.lock that will include internal vendored
RULE:     dependencies is described at:
RULE:     
https://github.com/ubuntu/ubuntu-project-docs/blob/main/docs/MIR/mir-rust.md
RULE:   - An example of how Rust dependency vendoring can be automated is
RULE:     "s390-tools", isolating crates in a .orig-vendor.tar.xz tarball:
RULE:     * 
https://git.launchpad.net/ubuntu/+source/s390-tools/tree/debian/rules
RULE:     Other examples include "authd" (for a native package, combined with
RULE:     Golang vendoring) and "gnome-snapshot" (using debian/missing-sources):
RULE:     * authd:
RULE:       https://github.com/ubuntu/authd/blob/main/debian/rules
RULE:     * gnome-snapshot:
RULE:       
https://salsa.debian.org/ubuntu-dev-team/snapshot/-/blob/ubuntu/latest/debian/README.source

RULE: - All vendored dependencies (no matter what language) shall have a
RULE:   way to be refreshed

This does not use static builds

This does not use vendored code

This does not use vendored code

This does not use vendored code

This package is not rust based


# -------- Recent-build
RULE: - Some packages build and update often, in this case everyone can just
RULE:   check the recent build logs to ensure if it builds fine.
RULE:   But some other packages are rather stable and have not been rebuilt
RULE:   in a long time. There no one can be confident it would build on e.g.
RULE:   an urgent security fix. Hence we ask if there has been a recent build.
RULE:   That might be a recent build that has been done anyway as seen on
RULE:   https://launchpad.net/ubuntu/+source/<source>, a reference to a recent
RULE:   archive test rebuild (those are announced on the ubuntu-devel mailing
RULE:   list like 
https://lists.ubuntu.com/archives/ubuntu-devel-announce/2024-January/001342.html),
RULE:   or a build set up by the reporter in a PPA with all architectures
RULE:   enabled.

The package has been built within the last 3 months in the archive

Build link on launchpad: https://launchpad.net/ubuntu/+source/gweather-
locations/2026.2-2/+build/33919610


# -------- Cross-team-impact
RULE: A few times we had packages that seemed fine for the package itself, but
RULE: caused quite some fallout and effort in related teams. We'd ask you to
RULE: think who else might be affected by promoting this package(s) and to
RULE: please coordinate with them upfront so they have time, understanding and
RULE: sympathy available.
RULE: Examples of the past which we admit could have been better (grows by
RULE: painful lessons learned):
RULE: - changing to rust coreutils forced us to update any apparmor profiles
RULE:   that referred to these paths

This change will not impact other teams

[Background information]
RULE: - The package descriptions should explain the general purpose and context
RULE:   of the package. Additional explanations/justifications should be done in
RULE:   the MIR report.
RULE: - If the package was renamed recently, or has a different upstream name,
RULE:   this needs to be explained in the MIR report.

The Package description explains the package well
Upstream Name is gweather-locations
Link to upstream project https://gitlab.gnome.org/GNOME/gweather-locations
Additional context:
  - New dependency added in Debian's libgweather 4.6.0
  - Simple data package containing location database files
  - Required to maintain consistency with Debian packaging

** Affects: ubuntu
     Importance: Undecided
         Status: New

-- 
You received this bug notification because you are a member of Ubuntu
Bugs, which is subscribed to Ubuntu.
https://bugs.launchpad.net/bugs/2174989

Title:
  [MIR] gweather-locations

To manage notifications about this bug go to:
https://bugs.launchpad.net/ubuntu/+bug/2174989/+subscriptions


-- 
ubuntu-bugs mailing list
[email protected]
https://lists.ubuntu.com/mailman/listinfo/ubuntu-bugs

Reply via email to