diff --git a/src/sdeventplus/internal/sdevent.hpp b/src/sdeventplus/internal/sdevent.hpp
index 7603a3d..e6c420c 100644
--- a/src/sdeventplus/internal/sdevent.hpp
+++ b/src/sdeventplus/internal/sdevent.hpp
@@ -25,6 +25,22 @@
         sd_event_source_ref(sd_event_source* source) const = 0;
     virtual sd_event_source*
         sd_event_source_unref(sd_event_source* source) const = 0;
+
+    virtual int
+        sd_event_source_get_description(sd_event_source* source,
+                                        const char** description) const = 0;
+    virtual int
+        sd_event_source_set_description(sd_event_source* source,
+                                        const char* description) const = 0;
+    virtual int sd_event_source_get_pending(sd_event_source* source) const = 0;
+    virtual int sd_event_source_get_priority(sd_event_source* source,
+                                             int64_t* priority) const = 0;
+    virtual int sd_event_source_set_priority(sd_event_source* source,
+                                             int64_t priority) const = 0;
+    virtual int sd_event_source_get_enabled(sd_event_source* source,
+                                            int* enabled) const = 0;
+    virtual int sd_event_source_set_enabled(sd_event_source* source,
+                                            int enabled) const = 0;
 };
 
 class SdEventImpl : public SdEvent
@@ -74,6 +90,41 @@
     {
         return ::sd_event_source_unref(source);
     }
+
+    int sd_event_source_get_description(sd_event_source* source,
+                                        const char** description) const override
+    {
+        return ::sd_event_source_get_description(source, description);
+    }
+    int sd_event_source_set_description(sd_event_source* source,
+                                        const char* description) const override
+    {
+        return ::sd_event_source_set_description(source, description);
+    }
+    int sd_event_source_get_pending(sd_event_source* source) const override
+    {
+        return ::sd_event_source_get_pending(source);
+    }
+    int sd_event_source_get_priority(sd_event_source* source,
+                                     int64_t* priority) const override
+    {
+        return ::sd_event_source_get_priority(source, priority);
+    }
+    int sd_event_source_set_priority(sd_event_source* source,
+                                     int64_t priority) const override
+    {
+        return ::sd_event_source_set_priority(source, priority);
+    }
+    int sd_event_source_get_enabled(sd_event_source* source,
+                                    int* enabled) const override
+    {
+        return ::sd_event_source_get_enabled(source, enabled);
+    }
+    int sd_event_source_set_enabled(sd_event_source* source,
+                                    int enabled) const override
+    {
+        return ::sd_event_source_set_enabled(source, enabled);
+    }
 };
 
 extern SdEventImpl sdevent_impl;
diff --git a/src/sdeventplus/source/base.cpp b/src/sdeventplus/source/base.cpp
index fd9b45f..d99d562 100644
--- a/src/sdeventplus/source/base.cpp
+++ b/src/sdeventplus/source/base.cpp
@@ -1,12 +1,93 @@
+#include <cerrno>
+#include <exception>
+#include <sdeventplus/exception.hpp>
 #include <sdeventplus/internal/sdevent.hpp>
 #include <sdeventplus/source/base.hpp>
+#include <stdexcept>
 #include <type_traits>
+#include <utility>
 
 namespace sdeventplus
 {
 namespace source
 {
 
+Base::~Base()
+{
+    set_enabled(SD_EVENT_OFF);
+}
+
+const char* Base::get_description()
+{
+    const char* description;
+    int r =
+        sdevent->sd_event_source_get_description(source.get(), &description);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_get_description");
+    }
+    return description;
+}
+
+void Base::set_description(const char* description)
+{
+    int r = sdevent->sd_event_source_set_description(source.get(), description);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_set_description");
+    }
+}
+
+int Base::get_pending()
+{
+    int r = sdevent->sd_event_source_get_pending(source.get());
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_get_pending");
+    }
+    return r;
+}
+
+int64_t Base::get_priority()
+{
+    int64_t priority;
+    int r = sdevent->sd_event_source_get_priority(source.get(), &priority);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_get_priority");
+    }
+    return priority;
+}
+
+void Base::set_priority(int64_t priority)
+{
+    int r = sdevent->sd_event_source_set_priority(source.get(), priority);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_set_priority");
+    }
+}
+
+int Base::get_enabled()
+{
+    int enabled;
+    int r = sdevent->sd_event_source_get_enabled(source.get(), &enabled);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_get_enabled");
+    }
+    return enabled;
+}
+
+void Base::set_enabled(int enabled)
+{
+    int r = sdevent->sd_event_source_set_enabled(source.get(), enabled);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_source_set_enabled");
+    }
+}
+
 Base::Base(sd_event_source* source, internal::SdEvent* sdevent) :
     sdevent(sdevent), source(source, &internal::SdEvent::sd_event_source_ref,
                              &internal::SdEvent::sd_event_source_unref, sdevent)
diff --git a/src/sdeventplus/source/base.hpp b/src/sdeventplus/source/base.hpp
index 88a17f0..20ab820 100644
--- a/src/sdeventplus/source/base.hpp
+++ b/src/sdeventplus/source/base.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <sdeventplus/internal/sdevent.hpp>
 #include <sdeventplus/internal/sdref.hpp>
 #include <systemd/sd-bus.h>
@@ -13,15 +14,25 @@
 class Base
 {
   public:
+    virtual ~Base();
+
     // We don't want to allow any kind of slicing.
     Base(const Base& source) = delete;
     Base& operator=(const Base& source) = delete;
     Base(Base&& source) = delete;
     Base& operator=(Base&& source) = delete;
 
+    const char* get_description();
+    void set_description(const char* description);
+    int get_pending();
+    int64_t get_priority();
+    void set_priority(int64_t priority);
+    int get_enabled();
+    void set_enabled(int enabled);
+
   protected:
-    internal::SdEvent* sdevent;
-    internal::SdRef<sd_event_source> source;
+    const internal::SdEvent* const sdevent;
+    const internal::SdRef<sd_event_source> source;
 
     // Base sources cannot be directly constructed.
     Base(sd_event_source* source,
diff --git a/src/sdeventplus/test/sdevent.hpp b/src/sdeventplus/test/sdevent.hpp
index 982e4e7..1cb723f 100644
--- a/src/sdeventplus/test/sdevent.hpp
+++ b/src/sdeventplus/test/sdevent.hpp
@@ -24,6 +24,21 @@
     MOCK_CONST_METHOD1(sd_event_source_ref, sd_event_source*(sd_event_source*));
     MOCK_CONST_METHOD1(sd_event_source_unref,
                        sd_event_source*(sd_event_source*));
+
+    MOCK_CONST_METHOD2(sd_event_source_get_description,
+                       int(sd_event_source*, const char**));
+    MOCK_CONST_METHOD2(sd_event_source_set_description,
+                       int(sd_event_source*, const char*));
+    MOCK_CONST_METHOD2(sd_event_source_set_prepare,
+                       int(sd_event_source*, sd_event_handler_t));
+    MOCK_CONST_METHOD1(sd_event_source_get_pending, int(sd_event_source*));
+    MOCK_CONST_METHOD2(sd_event_source_get_priority,
+                       int(sd_event_source*, int64_t*));
+    MOCK_CONST_METHOD2(sd_event_source_set_priority,
+                       int(sd_event_source*, int64_t));
+    MOCK_CONST_METHOD2(sd_event_source_get_enabled,
+                       int(sd_event_source*, int*));
+    MOCK_CONST_METHOD2(sd_event_source_set_enabled, int(sd_event_source*, int));
 };
 
 } // namespace test