Python

1. Setup your app folder

   mkdir reboot-hello && cd reboot-hello

2. Install Reboot

   python3 -m venv ./.venv && source .venv/bin/activate && pip install reboot

3. Make sure Docker is running:

   docker ps

4. Create a .proto file

   mkdir -p ./api/hello/v1 && touch ./api/hello/v1/hello.proto

5. Define your durable state data types and operations

   syntax = "proto3";
   
   package hello.v1;
   
   import "rbt/v1alpha1/options.proto";
   
   message Hello {
     option (rbt.v1alpha1.state) = {};
     repeated string messages = 1;
   }
   
   service HelloMethods {
     rpc Messages(MessagesRequest) returns (MessagesResponse) {
       option (rbt.v1alpha1.method).reader = {};
     }
   
     rpc Send(SendRequest) returns (SendResponse) {
       option (rbt.v1alpha1.method).writer = {};
     }
   }
   
   message MessagesRequest {}
   
   message MessagesResponse {
     repeated string messages = 1;
   }
   
   message SendRequest {
     string message = 1;
   }
   
   message SendResponse {}

6. Create .py implementation file

   mkdir -p ./backend/src && touch ./backend/src/hello_servicer.py

7. Implement HelloServicer

   from hello.v1.hello_rbt import (
       Hello,
       MessagesRequest,
       MessagesResponse,
       SendRequest,
       SendResponse,
   )
   from rebootdev.aio.contexts import ReaderContext, WriterContext
   
   class HelloServicer(Hello.Servicer):
   
       async def messages(
           self,
           context: ReaderContext,
           request: MessagesRequest,
       ) -> MessagesResponse:
           return MessagesResponse(messages=self.state.messages)
   
       async def send(
           self,
           context: WriterContext,
           request: SendRequest,
       ) -> SendResponse:
           self.state.messages.append(request.message)
           return SendResponse()

8. Create a main entrypoint

   touch ./backend/src/main.py

9. Implement main.py

   import asyncio
   from hello.v1.hello_rbt import Hello
   from hello_servicer import HelloServicer
   from reboot.aio.applications import Application
   from rebootdev.aio.external import InitializeContext
   
   async def initialize(context: InitializeContext):
       hello = Hello.ref('reboot-hello')
   
       await hello.send(
           context,
           message='Hello, World!',
       )
   
   
   async def main():
       application = Application(
           servicers=[HelloServicer],
           initialize=initialize,
       )
   
       await application.run()
   
   
   if __name__ == '__main__':
       asyncio.run(main())

10. Create an .rbtrc file

    touch .rbtrc

11. Add necessary flags to your .rbtrc file

    generate api/
    generate --python=backend/api/
    
    dev run --name=hello
    dev run --watch=backend/src/**/*.py
    dev run --python
    dev run --application=backend/src/main.py

12. Run your app

    rbt dev run

13. Query your app

    curl -XPOST http://localhost:9991/hello.v1.HelloMethods/Messages \
      -H "x-reboot-state-ref:hello.v1.Hello:reboot-hello"

Next steps

Well done! You made it!

This example is somewhat contrived as we only created one instance of your Hello data type, but in practice you are free to make as many of these as you like!

Check out these links to continue your exploration:

• Build a React frontend - create a React frontend that connects to your backend and displays your messages in real-time.
• Learn about transactions - so far, we've covered reader and writer methods, but Reboot's power extends to transactions. Learn about transactions and all of the other method kinds here.
• Join us on Discord - to ask questions and let us know what you think!

Hopefully, your wheels are starting to spin thinking of all of the possibilities!