Hacktoberfest 2026: the issues maintainers tagged for October, open and beginner-friendly. Browse Hacktoberfest issues

Receive pushed data into an archive through the Peer protocol

Open
  • Is something wrong?
#384 0 comments 0 reactions 0 assignees View on GitHub

Nobody has claimed this yet.

Assessment

Difficulty
4/5
Estimated time
3-5 days
Newbie friendliness
38/100
Issue type
Feature
Clarity
Clearly specified
Activity status
Active
Tech stack
django, python
Domain
backend, databases, distributed-systems

Research direction

Start with DiskSyncConnection in morango/sync/syncsession.py, then read TransferSessionViewSet and BufferViewSet in morango/api/viewsets.py, especially the scope checks at lines 348-354. Review spec §3.6 and implementation-plan Task 23 before implementing the six methods. Done means the listed acceptance criteria pass, including archive writes within assert_no_default_db_queries(); note that work is blocked by issues #367, #371, and #383.

Written by the indexing model from the issue text.

Description

DEV: backend P0 - critical TAG: new feature

Overview

A disk connection receives a push through the Peer protocol and stores the data in the archive, as a morango server does. This issue is part of milestone M6 (disk connection).

Background & Motivation

The shared Peer* operations from #374 drive a peer only through the Peer protocol. The network connection answers the protocol with HTTP calls to a server. The disk connection must answer the same protocol, with the archive in the role of the server.

The parity rule requires that the archive holds the same state as a server that receives the same push. For this reason, the disk connection calls the same receiver functions that the server uses. It does not use separate write logic.

Design: spec. Plan: implementation plan, Task 23.

User Story

As a Kolibri developer,
I want a push over a disk connection to complete all transfer stages,
So that the exported archive holds the same records and counters as a server.

Description & Expected Outcomes

The disk connection implements the six Peer protocol methods. It rejects a pull, because Phase 1 supports export only.

When a transfer session is created, the disk connection applies the same scope checks as the server. The filter must be in the write scope of the client certificate and the read scope of the archive certificate. The connection records the filter in the manifest.

When an update asks for a later stage, the disk connection runs each stage step in order up to that stage. It stops at the first step that does not complete. The steps compute the archive FSIC, accept record chunks, and dequeue the records into the archive store.

The disk connection returns every result as a PeerTransferSession. All writes to the archive happen inside a transaction on the archive alias.

Deliverables & Contracts

The feature delivers these capabilities:

  • create_transfer_session, get_transfer_session, update_transfer_session, close_transfer_session, push_record_chunk and pull_record_chunk on DiskSyncConnection, as spec §3.6 describes.
  • An update to a later stage runs every skipped stage step in order.
  • A push through the shared Peer* operations writes Store, RecordMaxCounter and DatabaseMaxCounter rows in the archive.
Acceptance Criteria
  • create_transfer_session for a pull raises MorangoError.
  • A filter outside the certificate scopes raises MorangoError.
  • create_transfer_session sets the manifest filter.
  • update_transfer_session(ts, transfer_stage="queuing") from initializing runs serializing and queuing, and returns stage queuing with status completed.
  • push_record_chunk sets the stage to transferring and increases records_transferred by the chunk length.
  • An update to dequeuing writes Store, RecordMaxCounter and DatabaseMaxCounter rows in the archive and increments the archive instance counter.
  • Two calls to close_transfer_session do not raise.
  • pull_record_chunk raises MorangoError.
  • All archive writes pass inside assert_no_default_db_queries().

Technical Pointers & Architecture

  • Target Components / Context: morango/sync/syncsession.py (DiskSyncConnection).
  • Related Patterns: TransferSessionViewSet (morango/api/viewsets.py:319) and BufferViewSet (morango/api/viewsets.py:452) are the server behavior to mirror. The scope checks are at morango/api/viewsets.py:348-354.
  • Data Model & Schema Considerations: No schema change.
  • Resilience & Failure Modes: The disk connection runs synchronously. Each stage step either completes or raises. Errors must not be suppressed.

Notes & Tradeoffs

  • Dependencies: Blocked by: #367 (receiver helpers take db), #371 (Peer protocol and PeerTransferSession), #383 (disk connection lifecycle). Blocks: #385, #386.
  • Kolibri companion changes: See spec §3.9. Kolibri routers must allow morango migrations on aliases that start with morango_archive_. Kolibri settings overrides must list the Peer* operations.
  • Tradeoffs & Alternatives Considered: The spec rejects a run of the server middleware against the archive. Server operations read the HTTP request, and host operations also run in that path. The contract suite in #385 guards against drift from server behavior.
  • Follow-up: A separate issue will split update_transfer_session into a field update and a stage advance (command-query separation).

Metadata

  • Complexity: High
  • Target Branch: release-v0.9.x

AI Usage

Drafted with Claude (Claude Code) from the approved design spec and implementation plan. The author reviewed the requirements, and the code references were checked against the release-v0.9.x codebase.

Dominant language
Python
Stars
15
Forks
23
Avg merge
1d 11h
Merged PRs (30d)
4

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from learningequality/morango

All issues in learningequality/morango

Similar issues

More Python issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.