Make sure required services are started in nix modules

Make nerd example config use HTTP REST API for reloading
Refactor controller to HTTP REST API
2024-03-24 14:42:46 +01:00 · 2023-12-25 18:48:54 +01:00 · 2023-12-25 18:45:02 +01:00 · 2023-12-23 22:13:27 +01:00 · 2023-10-17 21:59:47 +02:00 · 2023-10-17 20:44:13 +02:00
37 changed files with 3433 additions and 103 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,4 @@
 __pycache__
+dist/
+.venv
+result
--- a/674
+++ b/674
@@ -0,0 +1,674 @@
+GNU GENERAL PUBLIC LICENSE
+   Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+        Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+   TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+The Corresponding Source for a work in source code form is that
+same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+a) The work must carry prominent notices stating that you modified
+it, and giving a relevant date.
+
+b) The work must carry prominent notices stating that it is
+released under this License and any conditions added under section
+7.  This requirement modifies the requirement in section 4 to
+"keep intact all notices".
+
+c) You must license the entire work, as a whole, under this
+License to anyone who comes into possession of a copy.  This
+License will therefore apply, along with any applicable section 7
+additional terms, to the whole of the work, and all its parts,
+regardless of how they are packaged.  This License gives no
+permission to license the work in any other way, but it does not
+invalidate such permission if you have separately received it.
+
+d) If the work has interactive user interfaces, each must display
+Appropriate Legal Notices; however, if the Program has interactive
+interfaces that do not display Appropriate Legal Notices, your
+work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+a) Convey the object code in, or embodied in, a physical product
+(including a physical distribution medium), accompanied by the
+Corresponding Source fixed on a durable physical medium
+customarily used for software interchange.
+
+b) Convey the object code in, or embodied in, a physical product
+(including a physical distribution medium), accompanied by a
+written offer, valid for at least three years and valid for as
+long as you offer spare parts or customer support for that product
+model, to give anyone who possesses the object code either (1) a
+copy of the Corresponding Source for all the software in the
+product that is covered by this License, on a durable physical
+medium customarily used for software interchange, for a price no
+more than your reasonable cost of physically performing this
+conveying of source, or (2) access to copy the
+Corresponding Source from a network server at no charge.
+
+c) Convey individual copies of the object code with a copy of the
+written offer to provide the Corresponding Source.  This
+alternative is allowed only occasionally and noncommercially, and
+only if you received the object code with such an offer, in accord
+with subsection 6b.
+
+d) Convey the object code by offering access from a designated
+place (gratis or for a charge), and offer equivalent access to the
+Corresponding Source in the same way through the same place at no
+further charge.  You need not require recipients to copy the
+Corresponding Source along with the object code.  If the place to
+copy the object code is a network server, the Corresponding Source
+may be on a different server (operated by you or a third party)
+that supports equivalent copying facilities, provided you maintain
+clear directions next to the object code saying where to find the
+Corresponding Source.  Regardless of what server hosts the
+Corresponding Source, you remain obligated to ensure that it is
+available for as long as needed to satisfy these requirements.
+
+e) Convey the object code using peer-to-peer transmission, provided
+you inform other peers where the object code and Corresponding
+Source of the work are being offered to the general public at no
+charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+a) Disclaiming warranty or limiting liability differently from the
+terms of sections 15 and 16 of this License; or
+
+b) Requiring preservation of specified reasonable legal notices or
+author attributions in that material or in the Appropriate Legal
+Notices displayed by works containing it; or
+
+c) Prohibiting misrepresentation of the origin of that material, or
+requiring that modified versions of such material be marked in
+reasonable ways as different from the original version; or
+
+d) Limiting the use for publicity purposes of names of licensors or
+authors of the material; or
+
+e) Declining to grant rights under trademark law for use of some
+trade names, trademarks, or service marks; or
+
+f) Requiring indemnification of licensors and authors of that
+material by anyone who conveys the material (or modified versions of
+it) with contractual assumptions of liability to the recipient, for
+any liability that these contractual assumptions directly impose on
+those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+<one line to give the program's name and a brief idea of what it does.>
+Copyright (C) <year>  <name of author>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+<program>  Copyright (C) <year>  <name of author>
+This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+This is free software, and you are welcome to redistribute it
+under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
--- a/README.md
+++ b/README.md
@@ -2,9 +2,409 @@

 A simple to use, good enough phone system for medium sized DECT networks.

+## Setup
+
+FieldPOC requires a Mitel SIP DECT phone system, i.e. RFP L43 WLAN.
+Make sure you have the equipment, else this software is quit useless.
+
+This is more a sample setup.
+Everything described here can be done on multiple different ways.
+We just try to document a way that is proven to work.
+
+Get a computer, i.e. an APU Board, and install Archlinux on it.
+This can be a VM too, but you have to adapt stuff.
+
+### Config
+
+Create a file `fieldpoc_config.json`.
+This is your FieldPOC config in JSON format.
+You will add details to it with each step.
+
+### Networking
+
+We assume you use two network interfaces `enp2s0` and `enp3s0`.
+Configuration examples are for systemd-networkd.
+
+```
+systemctl enable --now systemd-networkd.service
+```
+
+Your FieldPOC box will act as a normal DHCP Client on `enp2s0`.
+This is the interface you connect to the internet and where you may connect to the box via SSH.
+
+`/etc/systemd/network/20-wired.network`
+```
+[Match]
+Name=enp2s0
+
+[Network]
+DHCP=yes
+```
+
+The other interface `enp3s0` will be the DECT network.
+This is the network where you connect your RFPs.
+We will run a dedicated DHCP Server on this network.
+
+`/etc/systemd/network/30-dect.network`
+```
+[Match]
+Name=enp3s0
+
+[Network]
+Address=10.222.222.1/24
+```
+
+As the DHCP Server for this network we use `kea`.
+
+```
+pacman -S kea
+```
+
+`/etc/kea/kea-dhcp4.conf`
+```
+{
+  "Dhcp4": {
+    "interfaces-config": {
+      "interfaces": [
+        "enp3s0"
+      ]
+    },
+    "lease-database": {
+      "name": "/var/lib/kea/dhcp4.leases",
+      "persist": true,
+      "type": "memfile"
+    },
+    "option-def": [
+      {
+        "code": 43,
+        "encapsulate": "sipdect",
+        "name": "vendor-encapsulated-options",
+        "space": "dhcp4",
+        "type": "empty"
+      },
+      {
+        "code": 10,
+        "name": "ommip1",
+        "space": "sipdect",
+        "type": "ipv4-address"
+      },
+      {
+        "code": 19,
+        "name": "ommip2",
+        "space": "sipdect",
+        "type": "ipv4-address"
+      },
+      {
+        "code": 14,
+        "name": "syslogip",
+        "space": "sipdect",
+        "type": "ipv4-address"
+      },
+      {
+        "code": 15,
+        "name": "syslogport",
+        "space": "sipdect",
+        "type": "int16"
+      },
+      {
+        "code": 224,
+        "name": "magic_str",
+        "space": "dhcp4",
+        "type": "string"
+      }
+    ],
+    "subnet4": [
+      {
+        "option-data": [
+          {
+            "data": "10.222.222.1",
+            "name": "routers"
+          }
+        ],
+        "pools": [
+          {
+            "pool": "10.222.222.100 - 10.222.222.200"
+          }
+        ],
+        "reservations": [
+          {
+            "hostname": "<name of your oom>",
+            "hw-address": "<mac address of your oom>",
+            "ip-address": "10.222.222.11",
+            "option-data": [
+              {
+                "data": "<name of your oom>",
+                "name": "host-name"
+              },
+              {
+                "name": "vendor-encapsulated-options"
+              },
+              {
+                "data": "10.222.222.11",
+                "name": "ommip1",
+                "space": "sipdect"
+              },
+              {
+                "data": "OpenMobilitySIP-DECT",
+                "name": "magic_str"
+              }
+            ]
+          }
+        ],
+        "subnet": "10.222.222.0/24"
+      }
+    ]
+  }
+}
+```
+
+Start the service.
+
+```
+systemctl enable --now kea-dhcp4
+```
+
+### Database
+
+```
+pacman -S postgresql
+```
+
+Init database.
+
+```
+su - postgres -c "initdb --locale en_US.UTF-8 -D '/var/lib/postgres/data'"
+```
+
+```
+systemctl enable --now postgresql
+```
+
+Open SQL shell
+
+```
+sudo -u postgres psql
+```
+
+Create database and user for routing engine.
+Change the password.
+
+```
+CREATE USER fieldpoc WITH PASSWORD 'fieldpoc';
+CREATE DATABASE fieldpoc WITH OWNER fieldpoc;
+```
+
+Add the database credetials to your `fieldpoc_config.json`.
+
+```
+{
+  "database": {
+    "host": "127.0.0.1",
+    "username": "fieldpoc",
+    "password": "fieldpoc",
+    "database": "fieldpoc"
+  }
+}
+```
+
+### Phone Server
+
+```
+pacman -S yate
+```
+
+Remove all files in `/etc/yate/` and add the following instead:
+
+#### Dialout SIP connection
+
+`accfile.conf`
+```
+[dialout]
+enabled=yes
+protocol=sip
+registrar=10.222.222.254
+username=dialout
+password=xxx
+```
+
+#### Call deduplication
+
+`cdrbuild.conf`
+```
+[parameters]
+X-Eventphone-Id=false
+```
+
+#### Yate remote control socket
+
+`extmodule.conf`
+```
+[listener fieldpoc]
+type=tcp
+addr=127.0.0.1
+port=5039
+```
+
+Add the information for the remote control socket to `fieldpoc_config.json`:
+
+```
+{
+  "yate": {
+    "host": "127.0.0.1",
+    "port": 5039
+  }
+}
+```
+
+#### Database connection
+
+Replace credentials with the ones you have choosen.
+
+`pgsqldb.conf`
+```
+[default]
+host=127.0.0.1
+database=fieldpoc
+user=fieldpoc    
+password=fieldpoc
+```
+
+#### Call routing
+
+`regexroute.conf`
+```
+[default]
+${username}^$=-;error=noauth
+^iocaste$=goto dialin
+^99991001$=tone/dial
+^99991002$=tone/busy
+^99991003$=tone/ring
+^99991004$=tone/specdial
+^99991005$=tone/congestion
+^99991006$=tone/outoforder
+^99991007$=tone/milliwatt
+^99991008$=tone/info
+^.*$=line/\0;line=dialout
+
+[dialin]
+${sip_x-called}^.*$=lateroute/\1
+```
+
+#### User registration
+
+`register.conf`
+```
+[general]
+expires=30
+
+user.auth=yes
+user.register=yes
+user.unregister=yes
+engine.timer=yes
+;call.preroute=no
+call.cdr=yes
+linetracker=yes
+
+[default]
+priority=10
+account=default
+
+[user.auth]
+query=SELECT password FROM users WHERE username='${username}' AND password IS NOT NULL AND password<>'' AND type='user' LIMIT 1;
+result=password
+
+[user.register]
+query=INSERT INTO registrations (username, location, oconnection_id, expires) VALUES ('${username}', '${data}', '${oconnection_id}', NOW() + INTERVAL '${expires} s') ON CONFLICT ON CONSTRAINT uniq_registrations DO UPDATE SET expires = NOW() + INTERVAL '${expires} s'
+
+[user.unregister]
+query=DELETE FROM registrations WHERE (username = '${username}' AND location = '${data}' AND oconnection_id = '${connection_id}') OR ('${username}' = '' AND '${data}' = '' AND oconnection_id = '${connection_id}')
+
+[engine.timer]
+query=DELETE FROM registrations WHERE expires<=CURRENT_TIMESTAMP;
+
+[call.cdr]
+critical=no
+
+[linetracker]
+critical=yes
+initquery=UPDATE users SET inuse=0 WHERE inuse is not NULL;DELETE from active_calls;
+cdr_initialize=UPDATE users SET inuse=inuse+1 WHERE username='${external}';INSERT INTO active_calls SELECT username, x_eventphone_id FROM (SELECT '${external}' as username, '${X-Eventphone-Id}' as x_eventphone_id, '${direction}' as direction) as active_call WHERE x_eventphone_id != '' AND x_eventphone_id IS NOT NULL and direction = 'outgoing';
+cdr_finalize=UPDATE users SET inuse=(CASE WHEN inuse>0 THEN inuse-1 ELSE 0 END) WHERE username='${external}';DELETE FROM active_calls WHERE username = '${external}' AND  x_eventphone_id = '${X-Eventphone-Id}' AND '${direction}' = 'outgoing';
+```
+
+### DECT
+
+Just choose one of your RFPs as your OMM.
+Find out the MAC address and fill it in the according fields in the kea config before.
+
+Please generate a 16-characters long hexadecimal string as `sipsecret`.
+This allowes the SIP accounts used for DECT phones to get a deterministic, but somewhat secure internal password.
+
+Create a privileged user account and add the credentials to `fieldpoc_config.json`:
+
+```
+{
+  "omm": {
+    "host": "10.222.222.11",
+    "username": "omm",
+    "password": "<password>"
+    "sipsecret": "<secret>"
+  }
+}
+```
+
+### FieldPOC
+
+Make sure Python is installed.
+
+```
+pacman -S python
+```
+
+Install FieldPOC:
+
+```
+pip install git+https://git.clerie.de/clerie/fieldpoc@main
+```
+
+FieldPOC provides a telnet socket for debugging and state mangement, add config for this to `fieldpoc_config.json` too:
+
+```
+{
+  "controller": {
+    "host": "127.0.0.1",
+    "port": 9437
+  }
+}
+```
+
+## Usage
+
+### Init
+
+Some datastructures have get prepared once:
+
+```
+fieldpoc -c /path/to/fieldpoc_config.json -e /path/to/fieldpoc_extensions.json --init
+```
+
+### Run
+
+```
+fieldpoc -c /path/to/fieldpoc_config.json -e /path/to/fieldpoc_extensions.json
+```
+
+## Debug
+
+Show log messages:
+
+```
+fieldpoc -c /path/to/fieldpoc_config.json -e /path/to/fieldpoc_extensions.json --debug
+```
+
 ## Development setup

-Make sure you have [mitel_ommclient2]() in your Python modules path.
+Make sure you have [mitel_ommclient2](https://git.clerie.de/clerie/mitel_ommclient2) in your Python modules path.

 Add user credentials to your OMM to `fieldpoc_config.json`.

@@ -21,3 +421,43 @@ List some options:
 ```
 python -m fieldpoc.run --help
 ```
+
+## Architecture
+
+FieldPOC is daemon that takes a defined state and makes all connected services fit that state.
+Each connected service is observed by a dedicated class executed in a seperate thread.
+There exist some more classes and threads to just glue everything together.
+
+### `extensions.json`
+
+The `extensions.json` file is the core of the whole setup and defines the state.
+It contains which extensions exist and for what they should be used.
+
+### `fieldpoc.py`
+
+This file containes the main class `FieldPOC`.
+It spawns the mentioned threads, initializes other classes and provices communication queues between the threads/classes.
+
+### `config.py`
+
+This manages FieldPOCs configuration.
+
+### `controller.py`
+
+The controller provices an interactive interface to manage and debug FieldPOC.
+
+### `run.py`
+
+This is a thin wrapper to start FieldPOC.
+
+### `dect.py`
+
+This deals with the Mitel OMM and configures all phones based on the current state.
+
+### `routing.py`
+
+This part sets up Yate using Ywsd, registers all extensions and configures routing.
+
+### `ywsd.py`
+
+This starts Ywsd with FieldPOC so you don't have to start it seperately.
--- a/docs/extension/multiple-rfps.md
+++ b/docs/extension/multiple-rfps.md
@@ -0,0 +1,6 @@
+# Multiple RFPs
+
+The [network setup described in the install section](../install/network.md) already accounts for multiple RFPs.
+Just add more to the same LAN.
+The DHCP options tell the other RFPs where they find the OMM.
+The additional RFPs show up in the OMM and have to be activated manually.
--- a/docs/extension/nerd.md
+++ b/docs/extension/nerd.md
@@ -0,0 +1,24 @@
+# Nerd web interface
+
+Nerd is a web interface for managing extensions.
+
+Source code: <https://github.com/dect-e/nerd/>
+
+## Sync extensions to FieldPOC
+
+Nerd has an HTTP endpoint generation a FieldPOC compatible extensions file.
+
+You can adopt the follwing NixOS configuration snipped.
+It downloads the JSON file, copies it to the location FieldPOC expects the extensions and reload FieldPOC.
+
+```
+systemd.services.fieldpoc-nerd = {
+wantedBy = ["multi-user.target"];
+startAt = "*-*-* *:*:00";
+script = ''
+  ${pkgs.curl}/bin/curl https://nerd.example.com/export.json\?event=1 > /etc/fieldpoc/extensions.json
+
+  ${pkgs.curl}/bin/curl --json '{}' http://127.0.0.1:9437/reload
+'';
+};
+```
--- a/docs/index.md
+++ b/docs/index.md
@@ -0,0 +1,5 @@
+# FieldPOC
+
+A simple to use, good enough phone system for medium sized DECT networks.
+
+The source code can be found at: <https://git.clerie.de/clerie/fieldpoc/>
--- a/docs/install/configure.md
+++ b/docs/install/configure.md
@@ -0,0 +1,21 @@
+# Configure FieldPOC
+
+To enable FieldPOC on the system just add this config.
+
+```
+services.fieldpoc = {
+  enable = true;
+  ommIp = "10.42.132.2";
+  ommUser = "omm";
+  ommPasswordPath = "/var/src/secrets/fieldpoc/ommpassword";
+  sipsecretPath = "/var/src/secrets/fieldpoc/sipsecret";
+};
+```
+
+- `ommIp` is the IP address of your OMM.
+- `ommUser` is the user account that FieldPOC uses to access the OMM. You usually want to set this to `omm`.
+- `ommPasswordPath` is the path to a file containing the password for the OMM user. This password is configured when [setting up the OMM](omm.md#login-credentials).
+
+- `sipsecretPath` is a path to a file containing a 16 characters hex string. FieldPOC is generating internal SIP accounts for each DECT user. So nobody can hijack these accounts, this secret is used as a seed for generating passwords for these accounts.
+
+When enabling the FieldPOC module a correctly configured Yate service is added to your system.
--- a/docs/install/hardware.md
+++ b/docs/install/hardware.md
@@ -0,0 +1,18 @@
+# Required hardware
+
+These are the hardware requirements for a minimal working system.
+
+## DECT Antenna
+
+FieldPOC is automation around the management API of Mitel DECT systems.
+So you need to have a [Mitel RFP 3rd gen](https://howto.dect.network/#hardware-rfp-generations).
+Our development setup currently uses an RFP 43 WLAN.
+
+## Powering the Antenna
+
+The RFP gets powered using PoE, so make sure you have a **PoE Injector**
+
+## Telephony Server
+
+The telephony server should be a x84 64bit computer with two Gigabit Ethernet RJ45 ports.
+In out case we use an APU Board, but it doesn't really matter.
--- a/docs/install/index.md
+++ b/docs/install/index.md
@@ -0,0 +1,16 @@
+# Installation overview
+
+FieldPOC requires a bunch of components to work together.
+We guide you through the setup of a minimal working system.
+Follow it in order and you will end up with a working setup.
+
+1. Required hardware
+2. Install NixOS
+3. Install FieldPOC
+4. Configure networking
+5. Configure FieldPOC
+6. Prepare RFP
+7. Setup OMM
+8. Have DECT
+
+There are plenty of options to extend the system and we try to document them in the following sections.
--- a/docs/install/network.md
+++ b/docs/install/network.md
@@ -0,0 +1,55 @@
+# Configure networking
+
+The hardware should have two network interfaces, so we can use one interface to connect the telephony server to the internet and access for management.
+The other network interface is used to connect to the DECT antenna.
+
+## Management and internet interface
+
+You can configure the interface for management and internet access how you like it.
+Usually leaving it with doing DHCP is totally find.
+
+## Interface for DECT antenna
+
+The telephony server is acting as a router for the DECT antenna.
+
+The network interface used in this example is called `enp3s0`.
+Replace it with the name of your own interface.
+
+Assign a static IP address to the interface:
+
+```
+networking.interfaces.enp3s0.ipv4.addresses = [ { address = "10.42.132.1"; prefixLength = 24; } ];
+```
+
+Phoning over the internet involves weird protocols.
+Because configuring firewalls for that use-case is hard, we disable the NixOS firewall on that interface.
+We can do that safely, as only the DECT antenna is connected to it and we have to trust it anyway.
+
+```
+networking.firewall.trustedInterfaces = [ "enp3s0" ];
+```
+
+### Configure DHCP server
+
+FieldPOC ships with some configuration wrapper that helps setting up the DHCP server required for the DECT antennas.
+
+```
+services.fieldpoc = {
+  dhcp = {
+    enable = true;
+    interface = "enp3s0";
+    subnet = "10.42.132.0/24";
+    pool = "10.42.132.200 - 10.42.132.250";
+    router = "10.42.132.1";
+    dnsServers = "10.42.10.8";
+    omm = "10.42.132.2";
+    reservations = [
+      {
+        name = "omm";
+        macAddress = "00:30:42:1b:8c:7c";
+        ipAddress = "10.42.132.2";
+      }
+    ];
+  };
+};
+```
--- a/docs/install/nixos.md
+++ b/docs/install/nixos.md
@@ -0,0 +1,25 @@
+# Install NixOS
+
+To coordinate all the different components, FieldPOC is packaged with NixOS.
+Follow [the official installation guide](https://nixos.org/manual/nixos/stable/#ch-installation) to install NixOS on you telephony server.
+You can use the minimal installer, as we don't need graphical user interface.
+
+## Add FieldPOC packages
+
+FieldPOC is provided as a Flake.
+
+Add the following inputs to your `flake.nix`:
+
+```
+inputs.fieldpoc.url = "git+https://git.clerie.de/clerie/fieldpoc.git";
+```
+
+Do not set the FielPOC flake to follow your nixpkgs input as this messes with the dependencies of FieldPOC.
+Especially the Python modules are incredibly dependent on specific version combinations to properly run.
+
+Add input modules to your system:
+
+```
+fieldpoc.nixosModules.default
+```
+
--- a/docs/install/omm.md
+++ b/docs/install/omm.md
@@ -0,0 +1,67 @@
+# Setup OMM
+
+OMM stands for Open Mobility Manager.
+It is there to manage multiple RFPs.
+
+## Designate OMM
+
+The OMM is a pice of software that can be hosted stand-alone or you can designate a RFP to be the OMM.
+In setups operating FieldPOC it is usually totally fine and recommended to just designate a RFP to be the OMM.
+
+RFPs automatically host the OMM when they receive their own IP address in the OMM field via DHCP.
+
+## Management interface
+
+The OMM exposes a web interface at their IP address.
+It is reachable via its IP address, port 443.
+
+## Setup
+
+When using the OMM the first time, some initial tasks have to be done.
+This only apply on a fresh factory reset RFP.
+
+You get a login screen without a PARK shown.
+
+You can login with the credentials `omm` and password `omm`.
+
+Afterwards you get propted to accept the EULA.
+
+### Login credentials
+
+You get asked to set a new password for user `omm`.
+Set a new password.
+Make sure to leave password aging to `None`.
+
+Next you get ask to set a password for the `root` user too.
+It is used to access the OMM via SSH.
+Set a password for it too.
+
+### Activate license
+
+You can configure many things, but the OMM does not really do anything without a license.
+
+Go to tab `System` and then `System Settings` and find row `PARK`.
+Load PARK file as explained in [howto.dect.network](https://howto.dect.network/#system-settings).
+
+Wait for OMM restarting.
+
+### SIP Settings
+
+Connect the OMM with the SIP server of FieldPOC.
+
+Go to tag `System`, then `SIP` and find rows `Proxy server` and `Registrar server`.
+Fill in the IPv4 address of the DECT network interface of the FieldPOC server (`10.42.132.1` in the example).
+Save using the `OK` button.
+
+### DECT devices subscription
+
+This enables DECT devices to connect to the phone system.
+
+Go to tab `SIP Users/Devices`.
+Set `DECT authentication code` to `0000`.
+Set checkbox in row `Auto-create on subscription`.
+Change the drop down in row `Subscription` to `Subscription`.
+Save using the `OK` button.
+
+> Sometimes the value in row `Subscription` changes to `Off` randomly.
+> If you can't subscribe new devices, make sure to check this option.
--- a/docs/install/rfp.md
+++ b/docs/install/rfp.md
@@ -0,0 +1,11 @@
+# Prepare RFP
+
+Before adding an RFP to your FieldPOC setup do a [software update](https://howto.dect.network/#software-update) to **SIP-DECT 8.1** and [factory reset them](https://howto.dect.network/#factory-reset).
+
+## Connecting RFP
+
+Connect the RFP with the PoE injector and then with the network interface of your telephony server that carries the network for the DECT antennas.
+
+RFPs will take a while to boot.
+First only one LED will glow.
+After a while more will add.
--- a/docs/operation/claim-dect-extension.md
+++ b/docs/operation/claim-dect-extension.md
@@ -0,0 +1,11 @@
+# Claim DECT extension
+
+Get a DECT phone an connect it to a new DECT base station.
+It will require an authentication code.
+This code got specified while [setting up the OMM](../install/omm.md#dect-devices-subscription).
+
+Wait for the base station registration succeed.
+
+After the base station registration wait a bit more to get a temporary number assigned.
+Then call `DECT claim token base` + `dect_claim_token`.
+The call should succeed and the DECT phone got the claimed token assigned.
--- a/docs/operation/troubleshooting.md
+++ b/docs/operation/troubleshooting.md
@@ -0,0 +1,8 @@
+# Troubleshooting
+
+## Registering DECT phone to base station does not work anymore
+
+Make sure DECT `Subscription` is still set to `Subscription`.
+Sometimes this changes back to `Off` by itself.
+
+See [OMM setup](../install/omm.md#dect-devices-subscription)
--- a/docs/reference/command-line-options.md
+++ b/docs/reference/command-line-options.md
@@ -0,0 +1,21 @@
+# Command line options
+
+## Config file path
+
+`-c`, `--config <path>`
+
+Specifies the path to [FieldPOC configuration file](configuration.md).
+Of ommitted it looks for a file called `fieldpoc_config.json` in the current working directory.
+
+## Init
+
+`--init`
+
+Set up database. Run only once.
+
+## Debug
+
+`--debug`
+
+Sets log level to debug.
+Logs to stdout.
--- a/docs/reference/configuration.md
+++ b/docs/reference/configuration.md
@@ -0,0 +1,60 @@
+# FieldPOC configuration
+
+`fieldpoc.json` is the main configuration file for FieldPOC. It is in JSON format.
+
+## Example config
+
+```
+{
+  "extensions": {
+    "file": "fieldpoc_extensions.json"
+  },
+  "controller": {
+    "host": "127.0.0.1",
+    "port": 9437
+  },
+  "dect": {
+    "host": "10.222.222.11",
+    "username": "omm",
+    "password": "xxx",
+    "sipsecret": "51df84aace052b0e75b8c1da5a6da9e2"
+  },
+  "yate": {
+    "host": "127.0.0.1",
+    "port": 5039
+  },
+  "database": {
+    "hostname": "127.0.0.1",
+    "username": "fieldpoc",
+    "password": "fieldpoc",
+    "database": "fieldpoc"
+  }
+}
+```
+
+## Controller
+
+Configuration for the FieldPOC controller.
+
+- `host`: IP address to listen on for controller socket.
+- `port`: Port to listen on for controller socket.
+
+## DECT
+
+- `host`: IP address of the OMM.
+- `username`: Username of OMM account.
+- `password`: Password of OMM account.
+- `sipsecret`: Secret used to seed DECT SIP account passwords.
+
+## Yate
+
+- `host`: IP address Yate control socket is reachable.
+- `port`: Port yate control socket is reachable.
+
+## Database
+
+- `hostname`: IP address PostgreSQL database is reachable.
+- `username`: Username of the database user.
+- `password`: Password of the database user.
+- `database`: Database name for FieldPOC.
+
--- a/docs/reference/controller.md
+++ b/docs/reference/controller.md
@@ -0,0 +1,46 @@
+# FieldPOC controller
+
+The FieldPOC controller is a HTTP REST API to help managing the current state of the FieldPOC system.
+
+Connect to it via the IP address von port set in the [FieldPOC configuration](configuration.md).
+
+## API Endpoints
+
+### `/sync`
+
+```bash
+curl --json '{}' http://127.0.0.1:9437/sync
+```
+
+Notify all parts of FieldPOC to check configuration of connected components and update it.
+
+### `/queues`
+
+```bash
+curl http://127.0.0.1:9437/queues
+```
+
+Show internal message queue stats.
+
+### `/reload`
+
+```bash
+curl --json '{}' http://127.0.0.1:9437/reload
+```
+
+Read [FieldPOC extensions specification](extensions.md) file and apply it.
+
+### `/claim`
+
+```bash
+curl --json '{"extension": "1111", "token": "1234"}' http://127.0.0.1:9437/claim
+```
+
+Bind extension to DECT device
+
+- `extension` is the current extension number of the DECT device.
+- `token` is the `dect_claim_token` of the extension that should get applied.
+
+This works because newly connected DECT phones get a temporary number assigned.
+This temporary number is usually the current number.
+But it is possible to use any extension, so the extension for a device can be changed any time.
--- a/docs/reference/extensions.md
+++ b/docs/reference/extensions.md
@@ -0,0 +1,100 @@
+# Extensions data
+
+`extensions.json` contains all extension a FieldPOC instance provides.
+
+## Example
+
+```
+{
+  "extensions": {
+    "2574": {
+      "name": "clerie",
+      "type": "dect",
+      "trunk": false,
+      "dialout_allowed": true,
+      "dect_claim_token": "2574"
+    },
+    "5375": {
+      "name": "n0emis",
+      "type": "callgroup",
+      "dialout_allowed": true,
+      "trunk": false,
+      "callgroup_members": [
+        "5376",
+        "5377",
+        "5379"
+      ]
+    },
+    "5376": {
+      "name": "n0emis SIP",
+      "type": "sip",
+      "dialout_allowed": true,
+      "trunk": false,
+      "outgoing_extension": "5375",
+      "sip_password": "wieK5xal"
+    },
+    "5377": {
+      "name": "n0emis DECT",
+      "type": "dect",
+      "dialout_allowed": true,
+      "trunk": false,
+      "outgoing_extension": "5375",
+      "dect_ipei": "10345 0136625 3"
+    },
+    "9998": {
+      "name": "Temporary Numbers",
+      "trunk": false,
+      "dialout_allowed": true,
+      "type": "temp"
+    },
+    "9997": {
+      "name": "DECT Claim Extensions",
+      "type": "static",
+      "dialout_allowed": false,
+      "trunk": true,
+      "static_target": "external/nodata//run/current-system/sw/bin/dect_claim"
+    }
+  }
+}
+
+```
+
+## Extensions definition
+
+The key for an extension is always the number of the extension.
+
+Following keys are required:
+
+- `name`: Description of the extension.
+- `type`: Type of the extension.
+
+## Extension types
+
+Based on the type of the extension more options are required.
+
+### SIP extension
+
+- `type`: `sip`
+- `sip_password`: Plain text password for the SIP account.
+
+### DECT extension
+
+- `type`: `dect`
+- `dect_claim_token`: Phone number part used to connect a DECT phone to this extension.
+- `dect_ipei`: IPEI of the DECT phone this extension should be connected to.
+
+`dect_claim_token` and `dect_ipei` are mutally exclusive.
+
+### Static extension
+
+- `type`: `static`
+- `static_target`: Path to script that is executed on calling this extension.
+
+### Temporary extension
+
+- `type`: `temp`
+
+### Callgroup extension
+
+- `type`: `callgroup`
+- `callgroup_members`: List of extension numbers that belong to this callgroup.
--- a/docs/reference/ywsd.md
+++ b/docs/reference/ywsd.md
@@ -0,0 +1,10 @@
+# YWSD
+
+FieldPOC is using [Yate Wähl System Digital](https://github.com/eventphone/ywsd) for call routing.
+
+The routes are stored in a PostgreSQL database that is populated by FieldPOC.
+Actual routing is handled by the YWSD software that is started as part of FieldPOC.
+
+When FieldPOC stopped, YWSD is stopped to.
+Therefore running calls will continue as long as everything else is working.
+But new calls can not be established.
--- a/fieldpoc/config.py
+++ b/fieldpoc/config.py
@@ -1,12 +1,18 @@
 #!/usr/bin/env python3

 class ConfigBase:
+    _DEFAULTS = {}
+
    def __init__(self, c):
        self._c = c

    def __getattr__(self, name):
+            # check if key is in config
            if name in self._c.keys():
                return self._c.get(name)
+            # check if key is in default config
+            elif name in self._DEFAULTS.keys():
+                return self._DEFAULTS.get(name)
            else:
                raise AttributeError()

@@ -15,39 +21,37 @@ class ControllerConfig(ConfigBase):
    def __init__(self, c):
        self._c = c

+class DatabaseConfig(ConfigBase):
+    pass
+

 class DectConfig(ConfigBase):
+    _DEFAULTS = {
+        "enabled": True,
+    }
+
    def __init__(self, c):
        self._c = c

    def check(self):
        return True

+class ExtensionsConfig(ConfigBase):
+    pass
+
+class YateConfig(ConfigBase):
+    _DEFAULTS = {
+        "enabled": True,
+    }
+

 class Config:
    def __init__(self, c):
-        self._c = c
        self.controller = ControllerConfig(c.get("controller", {}))
+        self.database = DatabaseConfig(c.get("database", {}))
        self.dect = DectConfig(c.get("dect", {}))
+        self.extensions = ExtensionsConfig(c.get("extensions", {}))
+        self.yate = YateConfig(c.get("yate", {}))

    def check(self):
        return self.dect.check()
-
-
-class ExtensionConfig:
-    def __init__(self, c):
-        self.num = c[0]
-        self._c = c[1]
-
-
-class Extensions:
-    def __init__(self, c):
-        self._c = c
-        self.extensions = []
-        for e in self._c.get("extensions", {}).items():
-            self.extensions.append(ExtensionConfig(e))
-
-    def extensions_by_type(self, t):
-        for e in self.extensions:
-            if e.type == t:
-                yield e
--- a/fieldpoc/controller.py
+++ b/fieldpoc/controller.py
@@ -1,86 +1,190 @@
 #!/usr/bin/env python3

 import logging
-import selectors
-import socket
-import socketserver
-import time
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler, HTTPStatus
 import threading
+import json

 logger = logging.getLogger("fieldpoc.controller")

 class Controller:
    def __init__(self, fp):
        self.fp = fp
-        self.handlers = [] # collect control sockets for handlers, so we can shut them down on demand

    def get_handler(self):
-        class HandleRequest(socketserver.BaseRequestHandler):
-            fp = self.fp
-            controller = self
+        """
+        Create a handler passed to the HTTP server

-            def setup(self):
-                self.handler_read, self.handler_write = socket.socketpair()
-                self.controller.handlers.append(self.handler_write)
+        Return a subclass of BaseHTTPRequestHandler
+        """

-            def handle(self):
-                self.request.sendall("FieldPOC interactive controller\n".encode("utf-8"))
+        # Paths by HTTP request method
+        PATHS = {
+            "GET": {},
+            "POST": {},
+        }

-                sel = selectors.DefaultSelector()
-                sel.register(self.handler_read, selectors.EVENT_READ)
-                sel.register(self.request, selectors.EVENT_READ)
-                while True:
-                    self.request.sendall("> ".encode("utf-8"))
+        def index():
+            """
+            Index page
+            """

-                    for key, mask in sel.select():
-                        if key.fileobj == self.handler_read:
-                            self.request.sendall("\ndisconnecting\n".encode("utf-8"))
-                            return
-                        elif key.fileobj == self.request:
-                            data = self.request.recv(1024).decode("utf-8").strip()
+            return "FieldPOC HTTP Controller"

-                            if data == "help":
-                                self.request.sendall("""Availiable commands:
-help       Show this info
-handlers   Show currently running handlers
-sync       Start syncing
-queues     Show queue stats
-exit       Disconnect
-""".encode("utf-8"))
-                            elif data == "quit" or data == "exit":
-                                self.request.sendall("disconnecting\n".encode("utf-8"))
-                                return
-                            elif data == "handlers":
-                                self.request.sendall(("\n".join([str(h) for h in self.controller.handlers]) + "\n").encode("utf-8"))
-                            elif data == "sync":
-                                self.fp.queue_all({"type": "sync"})
-                            elif data == "queues":
-                                self.request.sendall(("\n".join(["{} {}".format(name, queue.qsize()) for name, queue in self.fp.queues.items()]) + "\n").encode("utf-8"))
-                            else:
-                                self.request.sendall("Unknown command, type 'help'\n".encode("utf-8"))
+        PATHS["GET"]["/"] = index
+
+        def sync(payload):
+            """
+            Notify all parts of FieldPOC to check configuration of connected components and update it
+            """
+
+            self.fp.queue_all({"type": "sync"})
+
+            return "ok"
+
+        PATHS["POST"]["/sync"] = sync
+
+        def queues():
+            """
+            Show status of message queues
+            """
+
+            return {name: queue.qsize() for name, queue in self.fp.queues.items()}
+
+        PATHS["GET"]["/queues"] = queues
+
+        def reload(payload):
+            """
+            Read extensions specification and apply it
+            """
+
+            self.fp.reload_extensions()
+
+        PATHS["POST"]["/reload"] = reload
+
+        def claim(payload):
+            """
+            Bind extension to DECT device
+            """
+
+            if payload is None:
+                return {}
+            try:
+                self.fp.queue_all({"type": "claim", "extension": payload["extension"], "token": payload["token"]})
+                return "ok"
+            except KeyError:
+                return { "error": "You have to specify calling extension and token" }
+
+        PATHS["POST"]["/claim"] = claim
+
+        class HandleRequest(BaseHTTPRequestHandler):
+
+            def do_GET(self):
+                if self.path in PATHS["GET"]:
+                    response = PATHS["GET"][self.path]()
+                    return self.make_response(response)
+                else:
+                    self.send_error(HTTPStatus.NOT_FOUND, "Not found")
+                    return
+
+            def do_HEAD(self):
+                if self.path in PATHS["GET"]:
+                    response = PATHS["GET"][self.path]()
+                    return self.make_response(response, head_only=True)
+                else:
+                    self.send_error(HTTPStatus.NOT_FOUND, "Not found")
+                    return
+
+            def do_POST(self):
+                if self.path in PATHS["POST"]:
+                    payload = self.prepare_payload()
+                    response = PATHS["POST"][self.path](payload)
+                    return self.make_response(response)
+                else:
+                    self.send_error(HTTPStatus.NOT_FOUND, "Not found")
+                    return
+
+            def make_response(self, content, head_only=False):
+                """
+                Take a dict and return as HTTP json response
+                """
+
+                # Convert response to json
+                content = json.dumps(content) + "\n"
+                # Encode repose as binary
+                encoded = content.encode("utf-8")
+                # Send 200 status code
+                self.send_response(HTTPStatus.OK)
+                # Set json header
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                # Specify content length
+                self.send_header("Conten-Length", str(len(encoded)))
+                # Finish headers
+                self.end_headers()
+
+                # Return early on HEAD request
+                if head_only:
+                    return
+
+                # Send response
+                self.wfile.write(encoded)
+
+            def prepare_payload(self):
+                """
+                Read payload data from HTTP POST request and parse as json.
+                """
+
+                # Get payload length
+                length = int(self.headers["Content-Length"])
+                # Read payload up to length
+                encoded = self.rfile.read(length)
+                # Decode payload to string
+                content = encoded.decode("utf-8")
+
+                # Return early if no payload
+                if not content:
+                    return None
+
+                # Parse payload as json
+                return json.loads(content)

-            def finish(self):
-                self.controller.handlers.remove(self.handler_write)

        return HandleRequest


    def run(self):
        logger.info("starting server")
-        class Server(socketserver.ThreadingTCPServer):
+
+        class Server(ThreadingHTTPServer):
+            """
+            Subclass ThreadingHTTPServer to set custom options
+            """
+
+            # Sometimes sockets are still bound to addresses and ports
+            # we just ignore that with this
            allow_reuse_address = True

-        with Server((self.fp.config.controller.host, self.fp.config.controller.port), self.get_handler()) as server:
+        # Start the server
+        with Server(
+            # Passing address and port from config
+            (self.fp.config.controller.host, self.fp.config.controller.port),
+            # With the handler class we generated
+            self.get_handler()
+        ) as server:

+            # Starting server loop in another thread
            threading.Thread(target=server.serve_forever).start()

+            # Listen on the message queue
            while True:
+                # Wait for a new message and get it
                msg = self.fp.queues["controller"].get()
+                # Remove message from queue
                self.fp.queues["controller"].task_done()

                if msg.get("type") == "stop":
                    logger.info("stopping server")
+                    # Stop http server loop
                    server.shutdown()
-                    for h in self.handlers:
-                        h.send(b'\0')
+                    # Exist message queue listening loop
                    break
--- a/fieldpoc/dect.py
+++ b/fieldpoc/dect.py
@@ -3,12 +3,16 @@
 import logging
 import mitel_ommclient2
 import time
+import hashlib
+
+from .extensions import ExtensionConfig

 logger = logging.getLogger("fieldpoc.dect")

 class Dect:
    def __init__(self, fp):
        self.fp = fp
+        self.c = None # OOMClient2 not initialized at the beginning

    def _init_client(self):
        self.c = mitel_ommclient2.OMMClient2(
@@ -18,38 +22,211 @@ class Dect:
            ommsync=True,
        )

-    def get_temp_number(self):
-        temp_num_prefix = next(self.fp.extensions.extensions_by_type("temp")).num
+    @property
+    def temp_num_prefix(self):
+        return next(self.fp.extensions.extensions_by_type("temp")).num
+
+    def load_temp_extensions(self):
        current_temp_extension = 0
-        used_temp_extensions = [u.num[len(temp_num_prefix):] for u in self.c.find_users(lambda u: u.num.startswith(temp_num_prefix))]
+        used_temp_extensions = self.c.find_users(lambda u: u.num.startswith(self.temp_num_prefix))
+        for u in used_temp_extensions:
+            temp_num = u.num
+            self.fp.temp_extensions[temp_num] = ExtensionConfig(
+                num=temp_num,
+                name=f"Temp {temp_num[4:]}",
+                type="dect",
+                trunk=False,
+                dialout_allowed=False,
+            )
+
+    def get_temp_number(self):
+        current_temp_extension = 0
+        used_temp_extensions = [num[len(self.temp_num_prefix):] for num, ext in self.fp.temp_extensions.items()]

        while "{:0>4}".format(current_temp_extension) in used_temp_extensions:
            current_temp_extension += 1

-        return "{}{:0>4}".format(temp_num_prefix, current_temp_extension)
+        return "{}{:0>4}".format(self.temp_num_prefix, current_temp_extension)

    def get_sip_password_for_number(self, num):
-        return num
+        return hashlib.sha256(bytes.fromhex((self.fp.config.dect.sipsecret + str(num))[-16:])).hexdigest()[:16]

+    def create_and_bind_user(self, d, num):
+        u = self.c.create_user(num)
+        self.c.attach_user_device(u.uid, d.ppn)
+        self.c.set_user_relation_fixed(u.uid)
+        self.c.set_user_sipauth(u.uid, num, self.get_sip_password_for_number(num))
+        return u
+
+    def sync(self):
+        logger.info("syncing")
+
+        # load DECT extensions from configuration
+        extensions = self.fp.extensions.extensions_by_type("dect")
+        # accessible by extension number
+        extensions_by_num = {e.num: e for e in extensions}
+        # accessible by device IPEI, for devices with static IPEI in configuration
+        extensions_by_ipei = {e.dect_ipei: e for _, e in extensions_by_num.items() if e.dect_ipei is not None}
+
+        # signal if new extensions got created
+        created_tmp_ext = False
+
+        # collect users
+        users_by_ext = {}
+        users_by_uid = {}
+
+        # check all users on OMM
+        for user in self.c.get_users():
+            # check user on OMM against fieldpoc configuration
+            e = extensions_by_num.get(user.num)
+
+            # user in OMM, but no DECT extension in configuration
+            if not e:
+                # the user might have a temporary extension assigned, collect it
+                if user.num.startswith(next(self.fp.extensions.extensions_by_type("temp")).num):
+                    users_by_ext[user.num] = user
+                    users_by_uid[user.uid] = user
+
+                # we have no configuration for the user
+                else:
+                    # TODO: delete in omm
+                    pass
+
+                continue
+
+            # update user in OMM if name of extension changed
+            elif e.name != user.name:
+                self.c.set_user_name(user.uid, e.name)
+
+            if e.dect_ipei is not None and user.relType != mitel_ommclient2.types.PPRelTypeType("Unbound"):
+                d = self.c.get_device(user.ppn)
+                if d.ipei != e.dect_ipei:
+                    logger.debug(f"Detaching {user} {d}")
+                    self.c.detach_user_device(user.uid, user.ppn)
+
+            self.c.set_user_sipauth(user.uid, e.num, self.get_sip_password_for_number(e.num))
+            users_by_ext[user.num] = user
+            users_by_uid[user.uid] = user
+
+        # check all devices on OMM
+        for d in self.c.get_devices():
+
+            # find extension in fieldpoc configuration with static IPEI of the device on OMM
+            e = extensions_by_ipei.get(d.ipei)
+
+            # in case the IPEI is statically assigned to an extension
+            if e:
+                # find user on OMM configured for the selectied extension
+                u = users_by_ext.get(e.num)
+
+                # bind the user to the device if user exist and device is not bound to any user
+                if u and d.relType == mitel_ommclient2.types.PPRelTypeType("Unbound"):
+                    logger.debug(f'Binding user for {d}')
+                    self.c.attach_user_device(u.uid, d.ppn)
+                    self.c.set_user_relation_fixed(u.uid)
+
+                # fix user settings on OMM if device on OMM is already connected to a user
+                elif d.relType != mitel_ommclient2.types.PPRelTypeType("Unbound"):
+                    ui = users_by_uid.get(d.uid)
+                    if ui.num != e.num:
+                        logger.debug(f'User for {d} has wrong number')
+                        if self.fp.temp_extensions.get(ui.num):
+                            self.fp.temp_extensions.pop(ui.num)
+                        self.c.set_user_num(d.uid, e.num)
+                        self.c.set_user_sipauth(d.uid, e.num, self.get_sip_password_for_number(e.num))
+                        self.c.set_user_name(user.uid, e.name)
+
+                # create a new user on OMM if none exist and bind it to not bound device on OMM
+                else:
+                    logger.debug(f'Creating and binding user for {d}')
+                    user = self.create_and_bind_user(d, e.num)
+                    self.c.set_user_name(user.uid, e.name)
+
+            # assign any unbound device without static assigned IPEI a temporary extension
+            elif d.relType == mitel_ommclient2.types.PPRelTypeType("Unbound"):
+                temp_num = self.get_temp_number()
+                logger.debug(f'Creating and binding tmp-user for {d}: {temp_num}')
+                user = self.create_and_bind_user(d, temp_num)
+                self.c.set_user_name(user.uid, f"Temp {temp_num[4:]}")
+                self.fp.temp_extensions[temp_num] = ExtensionConfig(
+                        num=temp_num,
+                        name=f"Temp {temp_num[4:]}",
+                        type="dect",
+                        trunk=False,
+                        dialout_allowed=False,
+                )
+                created_tmp_ext = True
+
+        # update rounting when new extensions got created
+        if created_tmp_ext:
+            logger.info("notify for routing update")
+            self.fp.queues['routing'].put({"type": "sync"})
+
+        logger.info("finished sync")
+
+    def claim_extension(self, current_extension, token):
+        new_extension = None
+
+        # find an extension that can be claimed with the provided token
+        for ext in self.fp.extensions.extensions_by_type("dect"):
+            if ext.dect_claim_token == token:
+                new_extension = ext
+                break
+
+        if e:
+            # find user on OMM related to the current extension
+            user = next(self.c.find_users(lambda u: u.num == current_extension))
+
+            # if the current extension is a temporary extension, free it up again
+            if self.fp.temp_extensions.get(user.num):
+                self.fp.temp_extensions.pop(user.num)
+
+            # assign new extension to the user on OMM
+            self.c.set_user_num(user.uid, new_extension.num)
+            self.c.set_user_sipauth(user.uid, e.num, self.get_sip_password_for_number(new_extension.num))
+            self.c.set_user_name(user.uid, new_extension.name)

    def run(self):
-        logger.info("initialising connection to OMM")
-        self._init_client()
+        logger.info("starting dect thread")

        while True:
            msg = self.fp.queues["dect"].get()
            self.fp.queues["dect"].task_done()

            if msg.get("type") == "stop":
+                self.restart_loop = False
+                logger.info("stopped")
                break
-            elif msg.get("type") == "sync":
-                unbound_devices = self.c.find_devices(lambda d: d.relType == mitel_ommclient2.types.PPRelTypeType("Unbound"))

-                for d in unbound_devices:
-                    print(d)
-                    temp_num = self.get_temp_number()
-                    u = self.c.create_user(temp_num)
-                    print(u)
-                    self.c.attach_user_device(u.uid, d.ppn)
-                    self.c.set_user_relation_fixed(u.uid)
-                    self.c.set_user_sipauth(u.uid, temp_num, self.get_sip_password_for_number(temp_num))
+            else:
+                try:
+                    # setup connection to OMM
+                    if self.c is None:
+                        logger.info("initialising connection to OMM")
+                        self._init_client()
+                        self.load_temp_extensions()
+
+                    # handle tasks
+                    if msg.get("type") == "sync":
+                        self.sync()
+
+                    elif msg.get("type") == "claim":
+                        self.claim_extenstion(msg.get("extension"), msg.get("token")[4:])
+
+                except:
+                    logger.exception("task failed")
+
+                    # reset connection to OMM
+                    if self.c is not None:
+                        try:
+                            self.c.connection.close()
+                        except:
+                            pass
+                    self.c = None
+
+                    time.sleep(2)
+                    logger.info("requeue failed task")
+                    self.fp.queues["dect"].put(msg)
+
+        if self.c is not None:
+            self.c.connection.close()
--- a/fieldpoc/extensions.py
+++ b/fieldpoc/extensions.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+
+class ExtensionConfig:
+    num = None
+
+    callgroup_members = []
+    dect_claim_token = None
+    dect_ipei = None
+    dialout_allowed = False
+    name = None
+    outgoing_extension = None
+    sip_password = None
+    static_target = None
+    trunk = False
+    type = None
+
+    def __init__(self, **kwargs):
+        for name, value in kwargs.items():
+            if hasattr(type(self), name):
+                self.__setattr__(name, value)
+            else:
+                raise Exception("Invalid config option {}".format(name))
+
+        if self.type is None:
+            raise Exception("Type field for extension {} is required".format(self.num))
+        elif self.type == "dect":
+            if self.dect_ipei is not None and self.dect_claim_token is not None:
+                raise Exception("dect_ipei can't be used together with dect_claim_token in extension {}".format(self.num))
+        elif self.type == "sip":
+            if self.sip_password is None:
+                raise Exception("sip_password is required for sip extension {}".format(self.num))
+        elif self.type == "static":
+            if self.static_target is None:
+                raise Exception("static_target is required for static extension {}".format(self.num))
+
+    def check_global(self, extensions):
+        for e in extensions.extensions:
+            if e.num != self.num and e.num.startswith(self.num):
+                raise Exception("Extension {} uses {} as prefix, which is already defined as an extension".format(e.num, self.num))
+
+        if self.type == "callgroup":
+            for member in self.callgroup_members:
+                if member not in extensions.extensions_by_num.keys():
+                    raise Exception("Callgroup member {} of callgroup {} does not exist as extension".format(member, self.num))
+
+
+class Extensions:
+    extensions = []
+    extensions_by_num = {}
+
+    def __init__(self, c):
+        for num, e in c.get("extensions", {}).items():
+            extension_config = ExtensionConfig(**{
+                "num": num,
+            } | e)
+
+            self.extensions.append(extension_config)
+
+            if extension_config.num in self.extensions_by_num.keys():
+                raise Exception("Extension num already used {}".format(num))
+
+            self.extensions_by_num[num] = extension_config
+
+        for e in self.extensions:
+            e.check_global(self)
+
+
+    def extensions_by_type(self, t):
+        for e in self.extensions:
+            if e.type == t:
+                yield e
--- a/fieldpoc/fieldpoc.py
+++ b/fieldpoc/fieldpoc.py
@@ -8,30 +8,50 @@ import threading

 from . import config
 from . import controller
+from . import extensions
 from . import dect
+from . import routing
+from . import ywsd

 logger = logging.getLogger("fieldpoc.fieldpoc")

 class FieldPOC:
    config = None
    extensions = None
+    temp_extensions = {}

-    def __init__(self, config_file_path, extensions_file_path):
+    def __init__(self, config_file_path):
        logger.info("loading configuration")
        self.config_file_path = pathlib.Path(config_file_path)
        self._load_config()
-        self.extensions_file_path = pathlib.Path(extensions_file_path)
        self._load_extensions()

        logger.info("initialising queues")
        self.queues = {
            "controller": queue.Queue(),
            "dect": queue.Queue(),
+            "routing": queue.Queue(),
        }

        logger.info("initialising components")
        self._controller = controller.Controller(self)
        self._dect = dect.Dect(self)
+        self._routing = routing.Routing(self)
+        self._ywsd = ywsd.Ywsd(self)
+
+        logger.info("initialising threads")
+        self.threads = {
+            "controller": threading.Thread(target=self._controller.run),
+            "dect": threading.Thread(target=self._dect.run) if self.config.dect.enabled == True else None,
+            "routing": threading.Thread(target=self._routing.run),
+            "ywsd": threading.Thread(target=self._ywsd.run, daemon=True) if self.config.yate.enabled == True else None,
+        }
+
+        # Set thread names
+        for name, thread in self.threads.items():
+            if thread is None:
+                continue
+            thread.name = name

    def queue_all(self, msg):
        """
@@ -41,19 +61,43 @@ class FieldPOC:
        for queue in self.queues.values():
            queue.put(msg)

+    def init(self):
+        """
+            Prepare some data structures.
+            Run this once before using FieldPOC.
+        """
+
+        logger.info("initialize datastructures")
+
+        self._ywsd.init()
+
+        logger.info("initialization complete")
+
    def run(self):
-        logger.info("stating components")
+        """
+            Start FieldPOC
+        """

-        self._controller_thread = threading.Thread(target=self._controller.run)
-        self._controller_thread.start()
+        logger.info("starting threads")

-        self._dect_thread = threading.Thread(target=self._dect.run)
-        self._dect_thread.start()
+        for name, thread in self.threads.items():
+            if thread is None:
+                continue
+            thread.start()

-        logger.info("started components")
+        logger.info("started threads")
+
+    def reload_extensions(self):
+        self._load_extensions()
+        self.queue_all({"type": "sync"})

    def _load_config(self):
        self.config = config.Config(json.loads(self.config_file_path.read_text()))

    def _load_extensions(self):
-        self.extensions = config.Extensions(json.loads(self.extensions_file_path.read_text()))
+        try:
+            new_extensions = extensions.Extensions(json.loads(pathlib.Path(self.config.extensions.file).read_text()))
+        except:
+            logger.exception("loading extensions failed")
+        else:
+            self.extensions = new_extensions
--- a/fieldpoc/routing.py
+++ b/fieldpoc/routing.py
@@ -0,0 +1,502 @@
+#!/usr/bin/env python3
+
+import diffsync
+import logging
+import sqlalchemy
+from typing import Optional, List
+from ywsd.objects import Extension, ForkRank, User, Yate
+
+logger = logging.getLogger("fieldpoc.routing")
+
+class YateModel(diffsync.DiffSyncModel):
+    _modelname = "yate"
+    _identifiers = ("guru3_identifier",)
+    _attributes = (
+        "hostname",
+        "voip_listener",
+    )
+
+    guru3_identifier: str
+    hostname: str
+    voip_listener: str
+
+    yate_id: Optional[int]
+
+
+class YwsdYateModel(YateModel):
+    @classmethod
+    def create(cls, diffsync, ids, attrs):
+        with diffsync.engine.connect() as conn:
+            result = conn.execute(
+                Yate.table.insert().values(
+                    guru3_identifier=ids["guru3_identifier"], **attrs
+                )
+            )
+        attrs["yate_id"] = result.inserted_primary_key[0]
+        return super().create(diffsync, ids=ids, attrs=attrs)
+
+    def update(self, attrs):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                Yate.table.update()
+                .where(Yate.table.c.id == self.yate_id)
+                .values(**attrs)
+            )
+        return super().update(attrs)
+
+    def delete(self):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(Yate.table.delete().where(Yate.table.c.id == self.yate_id))
+        return super().delete()
+
+
+class ExtensionModel(diffsync.DiffSyncModel):
+    _modelname = "extension"
+    _identifiers = ("extension",)
+    _attributes = (
+        "yate",
+        "name",
+        "extension_type",
+        "outgoing_extension",
+        "dialout_allowed",
+        "forwarding_mode",
+        "lang",
+    )
+    _children = {"extension": "forwarding_extension"}
+
+    yate: Optional[str]
+    extension: str
+    name: Optional[str]
+    short_name: Optional[str]
+    extension_type: str
+    outgoing_extension: Optional[str]
+    outgoing_name: Optional[str]
+    dialout_allowed: bool
+    ringback: Optional[str]
+    forwarding_mode: str
+    forwarding_delay: Optional[int]
+    forwarding_extension: List = []
+    lang: str
+
+    extension_id: Optional[int]
+
+
+class YwsdExtensionModel(ExtensionModel):
+    @classmethod
+    def create(cls, diffsync, ids, attrs):
+        with diffsync.engine.connect() as conn:
+            result = conn.execute(
+                Extension.table.insert().values(
+                    extension=ids["extension"],
+                    type=attrs["extension_type"],
+                    yate_id=diffsync.get("yate", attrs["yate"]).yate_id
+                    if attrs.get("yate")
+                    else None,
+                    **dict(
+                        (k, v)
+                        for k, v in attrs.items()
+                        if k not in ["extension_type", "yate"]
+                    ),
+                )
+            )
+        attrs["extension_id"] = result.inserted_primary_key[0]
+        return super().create(diffsync, ids=ids, attrs=attrs)
+
+    def update(self, attrs):
+        with self.diffsync.engine.connect() as conn:
+            addn_attrs = {}
+            if attrs.get("extension_type"):
+                addn_attrs["type"] = attrs["extension_typ"]
+            if attrs.get("yate"):
+                addn_attrs["yate_id"] = (
+                    self.diffsync.get("yate", attrs["yate"]).yate_id,
+                )
+            conn.execute(
+                Extension.table.update()
+                .where(Extension.table.c.id == self.extension_id)
+                .values(
+                    **dict(
+                        (k, v)
+                        for k, v in attrs.items()
+                        if k not in ["extension_type", "yate"]
+                    ),
+                    **addn_attrs,
+                )
+            )
+        return super().update(attrs)
+
+    def delete(self):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                Extension.table.delete().where(
+                    Extension.table.c.id == self.extension_id
+                )
+            )
+        return super().delete()
+
+
+class UserModel(diffsync.DiffSyncModel):
+    _modelname = "user"
+    _identifiers = ("username",)
+    _attributes = (
+        "displayname",
+        "password",
+        "user_type",
+        "dect_displaymode",
+        "trunk",
+        "static_target",
+    )
+
+    username: str
+    displayname: Optional[str]
+    password: str
+    inuse: Optional[bool]
+    user_type: str
+    dect_displaymode: Optional[str]
+    trunk: Optional[bool]
+    static_target: Optional[str]
+
+
+class YwsdUserModel(UserModel):
+    @classmethod
+    def create(cls, diffsync, ids, attrs):
+        with diffsync.engine.connect() as conn:
+            conn.execute(
+                User.table.insert().values(
+                    username=ids["username"],
+                    type=attrs["user_type"],
+                    **dict((k, v) for k, v in attrs.items() if k not in ["user_type"]),
+                )
+            )
+        return super().create(diffsync, ids=ids, attrs=attrs)
+
+    def update(self, attrs):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                User.table.update()
+                .where(User.table.c.username == self.username)
+                .values(
+                    type=attrs.get("user_type", self.user_type),
+                    **dict((k, v) for k, v in attrs.items() if k not in ["user_type"]),
+                )
+            )
+        return super().update(attrs)
+
+    def delete(self):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                User.table.delete().where(User.table.c.username == self.username)
+            )
+        return super().delete()
+
+
+class ForkRankModel(diffsync.DiffSyncModel):
+    _modelname = "forkrank"
+    _identifiers = (
+        "extension",
+        "index",
+    )
+    _attributes = (
+        "mode",
+        "delay",
+    )
+
+    forkrank_id: Optional[int]
+    extension: str
+    index: int
+    mode: str
+    delay: Optional[int]
+
+
+class YwsdForkRankModel(ForkRankModel):
+    @classmethod
+    def create(cls, diffsync, ids, attrs):
+        with diffsync.engine.connect() as conn:
+            result = conn.execute(
+                ForkRank.table.insert().values(
+                    extension_id=diffsync.get(
+                        "extension", ids["extension"]
+                    ).extension_id,
+                    index=ids["index"],
+                    **attrs,
+                )
+            )
+        attrs["forkrank_id"] = result.inserted_primary_key[0]
+        return super().create(diffsync, ids=ids, attrs=attrs)
+
+    def update(self, attrs):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                ForkRank.table.update()
+                .where(ForkRank.table.c.id == self.forkrank_id)
+                .values(**attrs)
+            )
+        return super().update(attrs)
+
+    def delete(self):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                ForkRank.table.delete().where(ForkRank.table.c.id == self.forkrank_id)
+            )
+        return super().delete()
+
+
+class ForkRankMemberModel(diffsync.DiffSyncModel):
+    _modelname = "forkrankmember"
+    _identifiers = (
+        "forkrank",
+        "extension",
+    )
+    _attributes = (
+        "rankmember_type",
+        "active",
+    )
+
+    forkrank: str
+    extension: str
+    rankmember_type: str
+    active: bool
+
+
+class YwsdForkRankMemberModel(ForkRankMemberModel):
+    @classmethod
+    def create(cls, diffsync, ids, attrs):
+        with diffsync.engine.connect() as conn:
+            conn.execute(
+                ForkRank.member_table.insert().values(
+                    forkrank_id=diffsync.get("forkrank", ids["forkrank"]).forkrank_id,
+                    extension_id=diffsync.get(
+                        "extension", ids["extension"]
+                    ).extension_id,
+                    **attrs,
+                )
+            )
+        return super().create(diffsync, ids=ids, attrs=attrs)
+
+    def update(self, attrs):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                ForkRank.member_table.update()
+                .where(
+                    sqlalchemy.and_(
+                        ForkRank.member_table.c.forkrank_id
+                        == self.diffsync.get("forkrank", self.forkrank).forkrank_id,
+                        ForkRank.member_table.c.extension_id
+                        == self.diffsync.get("extension", self.extension).extension_id,
+                    )
+                )
+                .values(**attrs)
+            )
+        return super().update(attrs)
+
+    def delete(self):
+        with self.diffsync.engine.connect() as conn:
+            conn.execute(
+                ForkRank.member_table.delete().where(
+                    sqlalchemy.and_(
+                        ForkRank.member_table.c.forkrank_id
+                        == self.diffsync.get("forkrank", self.forkrank).forkrank_id,
+                        ForkRank.member_table.c.extension_id
+                        == self.diffsync.get("extension", self.extension).extension_id,
+                    )
+                )
+            )
+        return super().delete()
+
+
+class BackendFieldPOC(diffsync.DiffSync):
+    yate = YateModel
+    extension = ExtensionModel
+    user = UserModel
+    forkrank = ForkRankModel
+    forkrankmember = ForkRankMemberModel
+
+    top_level = ["yate", "extension", "user", "forkrank", "forkrankmember"]
+
+    def __init__(self, fp, *args, **kwargs):
+        self.fp = fp
+        super().__init__(*args, **kwargs)
+
+    def load(self, extensions):
+        #yate_dect = self.yate(
+        #    guru3_identifier="dect", hostname="dect", voip_listener="local"
+        #)
+        #self.add(yate_dect)
+        yate_sip = self.yate(
+            guru3_identifier="sip", hostname="sip", voip_listener="local"
+        )
+        self.add(yate_sip)
+
+        for num, extension in extensions.items():
+            yate = None
+            if extension.type in ["dect", "static"]:
+                # yate = yate_dect.guru3_identifier
+                yate = yate_sip.guru3_identifier
+            elif extension.type in ["sip"]:
+                yate = yate_sip.guru3_identifier
+            elif extension.type in ["callgroup"]:
+                forkrank = self.forkrank(extension=num, index=0, mode="DEFAULT")
+                self.add(forkrank)
+
+                for member in extension.callgroup_members:
+                    frm = self.forkrankmember(
+                        forkrank=forkrank.get_unique_id(),
+                        extension=member,
+                        rankmember_type="DEFAULT",
+                        active=True,
+                    )
+                    self.add(frm)
+            elif extension.type in ["temp"]:
+                continue
+
+            self.add(self.extension(
+                extension=num,
+                name=extension.name,
+                outgoing_extension=extension.outgoing_extension,
+                dialout_allowed=extension.dialout_allowed,
+                extension_type=("SIMPLE" if extension.trunk is not None else "TRUNK") if not extension.type == "callgroup" else "GROUP",
+                forwarding_mode="DISABLED",
+                lang="en-GB",
+                yate=yate,
+            ))
+
+            if extension.type in ["sip", "static", "dect"]:
+                user_type = {"sip": "user", "dect": "user", "static": "static"}
+                self.add(self.user(
+                    username=num,
+                    displayname=extension.name,
+                    password=extension.sip_password if extension.sip_password is not None else self.fp._dect.get_sip_password_for_number(num),
+                    user_type=user_type[extension.type],
+                    trunk=extension.trunk,
+                    static_target=extension.static_target if extension.static_target is not None else "",
+                ))
+
+
+class BackendYwsd(diffsync.DiffSync):
+    yate = YwsdYateModel
+    extension = YwsdExtensionModel
+    user = YwsdUserModel
+    forkrank = YwsdForkRankModel
+    forkrankmember = YwsdForkRankMemberModel
+
+    top_level = ["yate", "extension", "user", "forkrank", "forkrankmember"]
+
+    def load(self, database_url):
+        self.engine = sqlalchemy.create_engine(database_url)
+
+        extension_ids = {}
+        forkrank_ids = {}
+        with self.engine.connect() as conn:
+            for row in conn.execute(Yate.table.select()):
+                yate = self.yate(
+                    **dict(
+                        (k, v)
+                        for k, v in row._mapping.items()
+                        if k in ["guru3_identifier", "hostname", "voip_listener"]
+                    ),
+                    yate_id=row.id,
+                )
+                self.add(yate)
+            for row in conn.execute(Extension.table.select()):
+                extension = self.extension(
+                    **dict(
+                        (k, v)
+                        for k, v in row._mapping.items()
+                        if k
+                        in [
+                            "extension",
+                            "name",
+                            "short_name",
+                            "outgoing_extension",
+                            "outgoing_name",
+                            "dialout_allowed",
+                            "ringback",
+                            "forwarding_mode",
+                            "forwarding_delay",
+                            "lang",
+                        ]
+                    ),
+                    extension_type=row.type,
+                    extension_id=row.id,
+                )
+                extension_ids[row.id] = row.extension
+                # TODO: forwarding_extension_id
+                if row.yate_id:
+                    for yate in self.get_all("yate"):
+                        if yate.yate_id == row.yate_id:
+                            extension.yate = yate.guru3_identifier
+                self.add(extension)
+            for row in conn.execute(User.table.select()):
+                user = self.user(
+                    **dict(
+                        (k, v)
+                        for k, v in row._mapping.items()
+                        if k
+                        in [
+                            "username",
+                            "displayname",
+                            "password",
+                            "inuse",
+                            "dect_displaymode",
+                            "trunk",
+                            "static_target",
+                        ]
+                    ),
+                    user_type=row.type,
+                )
+                self.add(user)
+            for row in conn.execute(ForkRank.table.select()):
+                fr = self.forkrank(
+                    forkrank_id=row.id,
+                    extension=extension_ids[row.extension_id],
+                    **dict(
+                        (k, v)
+                        for k, v in row._mapping.items()
+                        if k in ["index", "mode", "delay"]
+                    ),
+                )
+                forkrank_ids[row.id] = fr.get_unique_id()
+                self.add(fr)
+            for row in conn.execute(ForkRank.member_table.select()):
+                frm = self.forkrankmember(
+                    forkrank=forkrank_ids[row.forkrank_id],
+                    extension=extension_ids[row.extension_id],
+                    **dict(
+                        (k, v)
+                        for k, v in row._mapping.items()
+                        if k in ["rankmember_type", "active"]
+                    ),
+                )
+                self.add(frm)
+
+
+class Routing:
+    def __init__(self, fp):
+        self.fp = fp
+
+    def run(self):
+        while True:
+            msg = self.fp.queues["routing"].get()
+            self.fp.queues["routing"].task_done()
+
+            if msg.get("type") == "stop":
+                break
+            elif msg.get("type") == "sync":
+
+                logger.info("syncing")
+
+                state_fieldpoc = BackendFieldPOC(self.fp)
+                extensions = self.fp.extensions.extensions_by_num.copy()
+                extensions.update(self.fp.temp_extensions)
+                state_fieldpoc.load(extensions)
+                state_yate = BackendYwsd()
+                state_yate.load("postgresql+psycopg2://{}:{}@{}/{}".format(
+                    self.fp.config.database.username,
+                    self.fp.config.database.password,
+                    self.fp.config.database.hostname,
+                    self.fp.config.database.database,
+                ))
+
+                logger.info("\n" + state_yate.diff_from(state_fieldpoc).str())
+
+                state_yate.sync_from(state_fieldpoc)
--- a/fieldpoc/run.py
+++ b/fieldpoc/run.py
@@ -12,7 +12,7 @@ logger = logging.getLogger("fieldpoc.run")

 ap = argparse.ArgumentParser(prog="fieldpoc")
 ap.add_argument("-c", "--config", dest="config_file_path", default="fieldpoc_config.json", help="Path to the fieldpoc config file")
-ap.add_argument("-e", "--extensions", dest="extensions_file_path", default="fieldpoc_extensions.json", help="Path to the fieldpoc extensions file")
+ap.add_argument('--init', dest="init", action='store_true')
 ap.add_argument('--debug', dest="debug", action='store_true')

 def run():
@@ -32,7 +32,12 @@ def run():

    logger.info("prepared signal handling")

-    fp = fieldpoc.FieldPOC(config_file_path=args.config_file_path, extensions_file_path=args.extensions_file_path)
+    fp = fieldpoc.FieldPOC(config_file_path=args.config_file_path)
+
+    if args.init:
+        fp.init()
+        exit()
+
    fp.run()

    logger.info("handle signals")
--- a/fieldpoc/ywsd.py
+++ b/fieldpoc/ywsd.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import aiopg.sa
+import asyncio
+import logging
+import ywsd.engine
+import ywsd.objects
+import ywsd.settings
+
+import yate.asyncio
+
+logger = logging.getLogger("fieldpoc.ywsd")
+
+### BEGIN Monkeypatches
+
+# disable asyncio signal handlers
+def add_signal_handler(*args, **kwargs):
+    raise NotImplementedError("Disable signal handling so we can run ywsd in a thread")
+asyncio.unix_events._UnixSelectorEventLoop.add_signal_handler = add_signal_handler
+
+# paython-yate stuff I have no idea why anymore
+async def setup_for_tcp(self, host, port):
+    self.reader, self.writer = await asyncio.open_connection(host, port)
+    self.send_connect()
+yate.asyncio.YateAsync.setup_for_tcp = setup_for_tcp
+
+### END Monkeypatches
+
+class Ywsd:
+    def __init__(self, fp):
+        self.fp = fp
+
+        self.event_loop = asyncio.SelectorEventLoop()
+
+    def settings(self):
+        class Settings(ywsd.settings.Settings):
+            def __init__(self, config):
+                self.config = config
+
+        return Settings({
+            "RINGBACK_TOP_DIRECTORY": "/opt/sounds",
+            "DB_CONFIG": {
+                "host": self.fp.config.database.hostname,
+                "user": self.fp.config.database.username,
+                "password": self.fp.config.database.password,
+                "database": self.fp.config.database.database,
+            },
+            "STAGE2_DB_CONFIG":{
+                "host": self.fp.config.database.hostname,
+                "user": self.fp.config.database.username,
+                "password": self.fp.config.database.password,
+                "database": self.fp.config.database.database,
+             },
+            "LOCAL_YATE_ID": 1,
+            "INTERNAL_YATE_LISTENER": "voip",
+            "CACHE_IMPLEMENTATION": "ywsd.routing_cache.PythonDictRoutingCache",
+            "YATE_CONNECTION":{
+                "host": self.fp.config.yate.host,
+                "port": self.fp.config.yate.port,
+            },
+        })
+
+    def init(self):
+        async def amain(settings):
+            async with aiopg.sa.create_engine(**settings.DB_CONFIG) as engine:
+                async with engine.acquire() as conn:
+                    await ywsd.objects.regenerate_database_objects(conn)
+
+        asyncio.run(amain(self.settings()))
+
+
+    def run(self):
+        asyncio.set_event_loop(self.event_loop)
+
+        logger.info("starting ywsd")
+        self.app = ywsd.engine.YateRoutingEngine(settings=self.settings(), web_only=False, **self.settings().YATE_CONNECTION)
+        self.app.event_loop = self.event_loop
+        self.app.run()
+
+        logger.info("stopped ywsd")
--- a/fieldpoc_config.json
+++ b/fieldpoc_config.json
@@ -1,11 +1,27 @@
 {
+  "extensions": {
+    "file": "fieldpoc_extensions.json"
+  },
  "controller": {
    "host": "127.0.0.1",
    "port": 9437
  },
  "dect": {
-    "host": "192.168.0.100",
+    "enabled": false,
+    "host": "10.222.222.11",
    "username": "omm",
-    "password": "xxx"
+    "password": "xxx",
+    "sipsecret": "51df84aace052b0e75b8c1da5a6da9e2"
+  },
+  "yate": {
+    "enabled": false,
+    "host": "127.0.0.1",
+    "port": 5039
+  },
+  "database": {
+    "hostname": "127.0.0.1",
+    "username": "fieldpoc",
+    "password": "fieldpoc",
+    "database": "fieldpoc"
  }
 }
--- a/fieldpoc_extensions.json
+++ b/fieldpoc_extensions.json
@@ -1,17 +1,108 @@
 {
  "extensions": {
+    "1000": {
+      "name": "strontium",
+      "type": "sip",
+      "dialout_allowed": true,
+      "trunk": false,
+      "sip_password": "AeShahS2"
+    },
+    "2020": {
+      "name": "Hotline",
+      "type": "static",
+      "dialout_allowed": false,
+      "trunk": false,
+      "static_target": "external/nodata//tmp/yate-tcl/hotline.tcl"
+    },
+    "2342": {
+      "name": "hydrox",
+      "type": "sip",
+      "dialout_allowed": true,
+      "trunk": false,
+      "sip_password": "Xua2liej"
+    },
    "2574": {
      "name": "clerie",
      "type": "dect",
+      "trunk": false,
+      "dialout_allowed": true,
      "dect_claim_token": "2574"
    },
+    "2789": {
+      "name": "bruttl",
+      "type": "dect",
+      "dialout_allowed": true,
+      "trunk": false,
+      "dect_ipei": "03586 0682136 3"
+    },
+    "5375": {
+      "name": "n0emis",
+      "type": "callgroup",
+      "dialout_allowed": true,
+      "trunk": false,
+      "callgroup_members": [
+        "5376",
+        "5377",
+        "5379"
+      ]
+    },
+    "5376": {
+      "name": "n0emis SIP",
+      "type": "sip",
+      "dialout_allowed": true,
+      "trunk": false,
+      "outgoing_extension": "5375",
+      "sip_password": "wieK5xal"
+    },
+    "5377": {
+      "name": "n0emis DECT",
+      "type": "dect",
+      "dialout_allowed": true,
+      "trunk": false,
+      "outgoing_extension": "5375",
+      "dect_ipei": "10345 0136625 3"
+    },
+    "5379": {
+      "name": "n0emis iPhone",
+      "type": "sip",
+      "dialout_allowed": true,
+      "trunk": false,
+      "outgoing_extension": "5375",
+      "sip_password": "uuchahD9"
+    },
+    "7486": {
+      "name": "floppy",
+      "type": "dect",
+      "dialout_allowed": true,
+      "trunk": false,
+      "dect_ipei": "12877 0914855 9"
+    },
+    "8463": {
+      "name": "Time",
+      "type": "static",
+      "dialout_allowed": false,
+      "trunk": false,
+      "static_target": "external/nodata//tmp/yate-tcl/time.tcl"
+    },
+    "8888": {
+      "name": "test",
+      "type": "static",
+      "dialout_allowed": true,
+      "trunk": false,
+      "static_target": "line/01754566012;line=dialout"
+    },
    "9998": {
      "name": "Temporary Numbers",
+      "trunk": false,
+      "dialout_allowed": true,
      "type": "temp"
    },
-    "9999": {
-      "name": "DECT Claim Token Pool",
-      "type": "claim_token"
+    "9997": {
+      "name": "DECT Claim Extensions",
+      "type": "static",
+      "dialout_allowed": false,
+      "trunk": true,
+      "static_target": "external/nodata//run/current-system/sw/bin/dect_claim"
    }
  }
 }
--- a/flake.lock
+++ b/flake.lock
@@ -0,0 +1,48 @@
+{
+  "nodes": {
+    "mitel-ommclient2": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1687019250,
+        "narHash": "sha256-cN9ZuQ/1irnoYg013v1ZDn15MHcFXhxILGhRNDGd794=",
+        "ref": "refs/heads/main",
+        "rev": "a11629f543a8b43451cecc46600a78cbb6af015a",
+        "revCount": 70,
+        "type": "git",
+        "url": "https://git.clerie.de/clerie/mitel_ommclient2.git"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://git.clerie.de/clerie/mitel_ommclient2.git"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1665732960,
+        "narHash": "sha256-WBZ+uSHKFyjvd0w4inbm0cNExYTn8lpYFcHEes8tmec=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "4428e23312933a196724da2df7ab78eb5e67a88e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "mitel-ommclient2": "mitel-ommclient2",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
--- a/flake.nix
+++ b/flake.nix
@@ -0,0 +1,154 @@
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    mitel-ommclient2 = {
+      url = "git+https://git.clerie.de/clerie/mitel_ommclient2.git";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+  outputs = { self, nixpkgs, mitel-ommclient2, ... }: let
+    fieldpoc_version = "0.11.0";
+  in {
+    packages.x86_64-linux = let
+      pkgs = import nixpkgs {
+        system = "x86_64-linux";
+      };
+    in {
+      fieldpoc = pkgs.python3Packages.buildPythonPackage {
+        pname = "fieldpoc";
+        version = fieldpoc_version;
+
+        src = ./.;
+
+        format = "pyproject";
+
+        buildInputs = [ pkgs.python3Packages.hatchling ];
+        propagatedBuildInputs = [
+          mitel-ommclient2.packages.x86_64-linux.mitel-ommclient2
+          pkgs.python3Packages.sqlalchemy
+          self.packages.x86_64-linux.ywsd
+          self.packages.x86_64-linux.diffsync
+        ];
+      };
+
+      ywsd = pkgs.python3Packages.buildPythonApplication rec {
+        pname = "ywsd";
+        version = "0.12.2";
+
+        src = pkgs.fetchFromGitHub {
+          owner = "eventphone";
+          repo = pname;
+          rev = "v${version}";
+          sha256 = "sha256-VkL7MhK6Z0Y1Hnnoq0Ukyclk9gfc4u8qav6yNj+LCJg=";
+        };
+
+        propagatedBuildInputs = [
+          pkgs.python3Packages.aiopg
+          pkgs.python3Packages.aiohttp
+          self.packages.x86_64-linux.python-yate
+          pkgs.python3Packages.pyyaml
+          pkgs.python3Packages.sqlalchemy
+        ];
+
+        doCheck = false;
+      };
+
+      python-yate = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "python-yate";
+        version = "0.4.1";
+
+        src = pkgs.python3Packages.fetchPypi {
+          inherit pname version;
+          sha256 = "sha256-rx0hcmP4SmvCkKXawyiMTKCVpTKTAgZVpbdQFdxV+hs=";
+        };
+
+        propagatedBuildInputs = [
+          pkgs.python3Packages.aiohttp
+          pkgs.python3Packages.async-timeout
+        ];
+
+        pythonImportsCheck = [ "yate" ];
+      };
+
+
+      diffsync = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "diffsync";
+        version = "1.5.1";
+
+        src = pkgs.python3Packages.fetchPypi {
+          inherit pname version;
+          sha256 = "84a736d03d385bd07cf7c86f57385d4130c3c3273bf7bc90febe2fa530ee1aa6";
+        };
+
+        propagatedBuildInputs = [
+          pkgs.python3Packages.pydantic
+          (pkgs.python3Packages.override {
+            overrides = (self: super: {
+              structlog = super.structlog.overrideAttrs (old: rec {
+                version = "21.5.0";
+                src = pkgs.fetchFromGitHub {
+                  owner = "hynek";
+                  repo = "structlog";
+                  rev = "refs/tags/${version}";
+                  sha256 = "0bc5lj0732j0hjq89llgrncyzs6k3aaffvg07kr3la44w0hlrb4l";
+                };
+              });
+            });
+          }).structlog
+          pkgs.python3Packages.colorama
+          pkgs.python3Packages.redis
+        ];
+
+        pythonImportsCheck = [ "diffsync" ];
+      };
+
+      yate = pkgs.yate.overrideAttrs (old: {
+        configureFlags = [ "--with-libpq=${pkgs.postgresql.withPackages (ps: [ ])}" ];
+      });
+
+      docs = pkgs.stdenv.mkDerivation {
+        pname = "fieldpoc-docs";
+        version = fieldpoc_version;
+
+        src = ./.;
+
+        buildInputs = [
+          pkgs.python3.pkgs.mkdocs-material
+        ];
+
+        buildPhase = ''
+          python3 -m mkdocs build
+        '';
+
+        installPhase = ''
+          mkdir -p $out
+          cp -r ./site/* $out/
+        '';
+      };
+    };
+
+    nixosModules = {
+      fieldpoc = { ... }: {
+        imports = [
+          ./nix/modules/dhcp.nix
+          ./nix/modules/fieldpoc.nix
+          ./nix/modules/yate.nix
+        ];
+
+        nixpkgs.overlays = [
+          (_: _: {
+            inherit (self.packages."x86_64-linux")
+              fieldpoc
+              yate;
+          })
+        ];
+      };
+      default = self.nixosModules.fieldpoc;
+    };
+
+    hydraJobs = {
+      inherit (self)
+        packages;
+    };
+  };
+}
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -0,0 +1,27 @@
+site_name: FieldPOC
+
+theme:
+  name: material
+
+nav:
+  - index.md
+  - Installation:
+    - install/index.md
+    - install/hardware.md
+    - install/nixos.md
+    - install/network.md
+    - install/configure.md
+    - install/rfp.md
+    - install/omm.md
+  - Reference:
+    - reference/command-line-options.md
+    - reference/configuration.md
+    - reference/extensions.md
+    - reference/controller.md
+    - reference/ywsd.md
+  - Operation:
+    - operation/claim-dect-extension.md
+    - operation/troubleshooting.md
+  - Extend:
+    - extension/nerd.md
+    - extension/multiple-rfps.md
--- a/nix/modules/dhcp.nix
+++ b/nix/modules/dhcp.nix
@@ -0,0 +1,141 @@
+{ config, pkgs, lib, ... }:
+
+with lib;
+
+let
+  cfg = config.services.fieldpoc.dhcp;
+in {
+  options.services.fieldpoc.dhcp = {
+    enable = mkEnableOption "fieldpoc-dhcp";
+    interface = mkOption {
+      type = types.str;
+    };
+    subnet = mkOption {
+      type = types.str;
+    };
+    pool = mkOption {
+      type = types.str;
+    };
+    router = mkOption {
+      type = types.str;
+    };
+    dnsServers = mkOption {
+      type = types.str;
+    };
+    omm = mkOption {
+      type = types.str;
+    };
+    reservations = mkOption {
+      type = with types; listOf (submodule {
+        options = {
+          name = mkOption {
+            type = types.str;
+          };
+          macAddress = mkOption {
+            type = types.str;
+          };
+          ipAddress = mkOption {
+            type = types.str;
+          };
+        };
+      });
+      default = [];
+    };
+  };
+
+  config = mkIf cfg.enable {
+    services.kea.dhcp4 = {
+      enable = true;
+      settings = {
+        interfaces-config = {
+          interfaces = [ cfg.interface ];
+        };
+        option-def = [
+          {
+            space = "dhcp4";
+            name = "vendor-encapsulated-options";
+            code = 43;
+            type = "empty";
+            encapsulate = "sipdect";
+          }
+          {
+            space = "sipdect";
+            name = "ommip1";
+            code = 10;
+            type = "ipv4-address";
+          }
+          {
+            space = "sipdect";
+            name = "ommip2";
+            code = 19;
+            type = "ipv4-address";
+          }
+          {
+            space = "sipdect";
+            name = "syslogip";
+            code = 14;
+            type = "ipv4-address";
+          }
+          {
+            space = "sipdect";
+            name = "syslogport";
+            code = 15;
+            type = "int16";
+          }
+          {
+            space = "dhcp4";
+            name = "magic_str";
+            code = 224;
+            type = "string";
+          }
+        ];
+
+        subnet4 = [
+          {
+            subnet = cfg.subnet;
+            pools = [
+              {
+                pool = cfg.pool;
+              }
+            ];
+            option-data = [
+              {
+                name = "routers";
+                data = cfg.router;
+              }
+              {
+                name = "domain-name-servers";
+                data = cfg.dnsServers;
+              }
+              {
+                name = "vendor-encapsulated-options";
+              }
+              {
+                space = "sipdect";
+                name = "ommip1";
+                data = cfg.omm;
+              }
+              {
+                name = "magic_str";
+                data = "OpenMobilitySIP-DECT";
+              }
+            ];
+
+            reservations = map (r: {
+              hostname = r.name;
+              hw-address = r.macAddress;
+              ip-address = r.ipAddress;
+              option-data = [
+                {
+                  name = "host-name";
+                  data = r.name;
+                }
+              ];
+            }) cfg.reservations;
+          }
+        ];
+      };
+    };
+  };
+}
+
--- a/nix/modules/fieldpoc.nix
+++ b/nix/modules/fieldpoc.nix
@@ -0,0 +1,157 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.fieldpoc;
+in {
+  options = {
+    services.fieldpoc = {
+      enable = mkEnableOption "fieldpoc";
+      ommIp = mkOption {
+        type = types.str;
+      };
+      ommUser = mkOption {
+        type = types.str;
+      };
+      ommPasswordPath = mkOption {
+        type = types.path;
+      };
+      sipsecretPath = mkOption {
+        type = types.path;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    environment.systemPackages = with pkgs; [
+      fieldpoc
+    ];
+
+    systemd.services.fieldpoc = {
+      description = "Fieldpoc daemon";
+      wantedBy = [ "multi-user.target" ];
+      requires = [ "network-online.target" "yate.service" ];
+      after = [ "network-online.target" "yate.service" ];
+
+      serviceConfig = {
+        Type = "simple";
+        ExecStart = "${pkgs.fieldpoc}/bin/fieldpoc -c /run/fieldpoc/config.json --debug";
+        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+        User = "fieldpoc";
+        Group = "fieldpoc";
+        RuntimeDirectory = "fieldpoc";
+        RuntimeDirectoryMode = "0755";
+        ConfigurationDirectory = "fieldpoc";
+        StateDirectory = "fieldpoc";
+        StateDirectoryMode = "0700";
+      };
+
+      preStart = let
+        cfgFile = pkgs.writeText "config.json" (lib.generators.toJSON { } {
+          extensions = {
+            file = "/var/lib/fieldpoc/extensions.json";
+          };
+          controller = {
+            host = "127.0.0.1";
+            port = 9437;
+          };
+          dect = {
+            host = cfg.ommIp;
+            username = cfg.ommUser;
+            password = "!!OMMPASSWORD!!";
+            sipsecret = "!!SIPSECRET!!";
+          };
+          yate = {
+            host = "127.0.0.1";
+            port = 5039;
+          };
+          database = {
+            hostname = "127.0.0.1";
+            username = "fieldpoc";
+            password = "fieldpoc";
+            database = "fieldpoc";
+          };
+        });
+      in ''
+        ${pkgs.gnused}/bin/sed -e "s/!!OMMPASSWORD!!/$(cat ${cfg.ommPasswordPath})/g" -e "s/!!SIPSECRET!!/$(cat ${cfg.sipsecretPath})/g" ${cfgFile} > /run/fieldpoc/config.json
+        if [ ! -f "/var/lib/fieldpoc/extensions.json" ]; then
+          echo '{"extensions": {}}' > /var/lib/fieldpoc/extensions.json
+        fi
+      '';
+    };
+
+    users.users.fieldpoc = {
+      isSystemUser = true;
+      group = "fieldpoc";
+    };
+
+    users.groups.fieldpoc = { };
+
+    services.postgresql = {
+      enable = true;
+      initialScript = pkgs.writeText "backend-initScript" ''
+        CREATE ROLE fieldpoc WITH LOGIN PASSWORD 'fieldpoc' CREATEDB;
+        CREATE DATABASE fieldpoc;
+        GRANT ALL PRIVILEGES ON DATABASE fieldpoc TO fieldpoc;
+      '';
+    };
+
+    services.yate = {
+      enable = true;
+      config = {
+        extmodule = {
+          "listener ywsd" = {
+            type = "tcp";
+            addr = "127.0.0.1";
+            port = "5039";
+          };
+        };
+        cdrbuild = {
+          parameters = {
+            X-Eventphone-Id = "false";
+          };
+        };
+        pgsqldb = {
+          default = {
+            host = "localhost";
+            port = "5432";
+            database = "fieldpoc";
+            user = "fieldpoc";
+            password = "fieldpoc";
+          };
+        };
+        register = {
+          general = {
+            expires = 30;
+            "user.auth" = "yes";
+            "user.register" = "yes";
+            "user.unregister" = "yes";
+            "engine.timer" = "yes";
+            "call.cdr" = "yes";
+            "linetracker" = "yes";
+          };
+          default = {
+            priority = 30;
+            account = "default";
+          };
+          "user.auth" = {
+            query = "SELECT password FROM users WHERE username='\${username}' AND password IS NOT NULL AND password<>'' AND type='user' LIMIT 1;";
+            result = "password";
+          };
+          "user.register".query = "INSERT INTO registrations (username, location, oconnection_id, expires) VALUES ('\${username}', '\${data}', '\${oconnection_id}', NOW() + INTERVAL '\${expires} s') ON CONFLICT ON CONSTRAINT uniq_registrations DO UPDATE SET expires = NOW() + INTERVAL '\${expires} s'";
+          "user.unregister".query = "DELETE FROM registrations WHERE (username = '\${username}' AND location = '\${data}' AND oconnection_id = '\${connection_id}') OR ('\${username}' = '' AND '\${data}' = '' AND oconnection_id = '\${connection_id}')";
+          "engine.timer".query = "DELETE FROM registrations WHERE expires<=CURRENT_TIMESTAMP;";
+          "call.cdr".critial = "no";
+          "linetracker" = {
+            critical = "yes";
+            initquery = "UPDATE users SET inuse=0 WHERE inuse is not NULL;DELETE from active_calls;";
+            cdr_initialize = "UPDATE users SET inuse=inuse+1 WHERE username='\${external}';INSERT INTO active_calls SELECT username, x_eventphone_id FROM (SELECT '\${external}' as username, '\${X-Eventphone-Id}' as x_eventphone_id, '\${direction}' as direction) as active_call WHERE x_eventphone_id != '' AND x_eventphone_id IS NOT NULL and direction = 'outgoing';";
+            cdr_finalize = "UPDATE users SET inuse=(CASE WHEN inuse>0 THEN inuse-1 ELSE 0 END) WHERE username='\${external}';DELETE FROM active_calls WHERE username = '\${external}' AND  x_eventphone_id = '\${X-Eventphone-Id}' AND '\${direction}' = 'outgoing';";
+          };
+        };
+      };
+    };
+  };
+}
+
--- a/nix/modules/yate.nix
+++ b/nix/modules/yate.nix
@@ -0,0 +1,57 @@
+
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.yate;
+in {
+  options = {
+    services.yate = {
+      enable = mkEnableOption "yate";
+      config = mkOption {
+        type = with types; attrsOf anything;
+        default = { };
+      };
+    };
+  };
+  config = mkIf cfg.enable {
+    environment.etc = mapAttrs' (name: config: nameValuePair "yate/${name}.conf" { text = (if (isAttrs config) then generators.toINI {} config else config); }) cfg.config;
+
+    systemd.services.yate = {
+      description = "YATE Telephony Server";
+      wantedBy = [ "multi-user.target" ];
+      requires = [ "network-online.target" "postgresql.service" ];
+      after = [ "network-online.target" "postgresql.service" ];
+
+      environment = { PWLIB_ASSERT_ACTION = "C"; };
+
+      serviceConfig = {
+        Type = "forking";
+        ExecStart =
+          "${pkgs.yate}/bin/yate -d -p /run/yate/yate.pid -c /etc/yate -F -s -vvv -DF -r -l /var/lib/yate/yate.log";
+        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+        User = "yate";
+        Group = "yate";
+        AmbientCapabilities = "CAP_NET_BIND_SERVICE";
+        RuntimeDirectory = "yate";
+        RuntimeDirectoryMode = "0755";
+        ConfigurationDirectory = "yate";
+        StateDirectory = "yate";
+        StateDirectoryMode = "0700";
+        PIDFile = "/run/yate/yate.pid";
+        TimeoutSec = 30;
+      };
+
+      reloadTriggers = map (name: config.environment.etc."yate/${name}.conf".source) (attrNames cfg.config);
+    };
+
+    users.users.yate = {
+      isSystemUser = true;
+      group = "yate";
+    };
+
+    users.groups.yate = { };
+  };
+}
+
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fieldpoc"
+version = "0.0.1"
+authors = [
+  { name="clerie" },
+]
+description = "A simple to use, good enough phone system for medium sized DECT networks."
+readme = "README.md"
+license = { file="LICENSE" }
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Communications :: Telephony",
+]
+dependencies = [
+  "mitel-ommclient2",
+  "sqlalchemy",
+  "ywsd",
+]
+
+[project.scripts]
+fieldpoc = "fieldpoc.run:run"
+
+[project.urls]
+"Source" = "https://git.clerie.de/clerie/fieldpoc"
Author	SHA1	Message	Date
clerie	f707f21237	Make sure required services are started in nix modules	2024-03-24 14:42:46 +01:00
clerie	3197e4f8d3	Make nerd example config use HTTP REST API for reloading	2023-12-25 18:48:54 +01:00
clerie	b820eaff52	Refactor controller to HTTP REST API	2023-12-25 18:45:02 +01:00
clerie	6d016d272f	Allow specific components to be enabled an disabled	2023-12-23 22:13:27 +01:00
clerie	9571f38965	Add notice about YWSD in docs	2023-10-17 21:59:47 +02:00
clerie	c21f8f0e16	Add docs for multiple RFPs	2023-10-17 20:44:13 +02:00
clerie	d23c1fbedb	Specify FieldPOC version once in flake.nix	2023-10-14 21:26:27 +02:00
clerie	a35780e489	Document integration of nerd	2023-10-14 21:09:26 +02:00
clerie	74d682272c	Add docs for operating FieldPOC	2023-10-14 20:59:36 +02:00
clerie	aa06353a18	Add link to git repo in docs	2023-10-14 20:20:22 +02:00
clerie	928d23ce14	Document extensions file and FieldPOC controller	2023-10-14 20:19:26 +02:00
clerie	42686f1f41	Document command line options	2023-10-14 19:24:05 +02:00
clerie	b59c8bfd05	Add FieldPOC configuration reference	2023-10-14 18:41:20 +02:00
clerie	190d89eb2c	Moving installation docs to seperate directory	2023-10-14 18:24:16 +02:00
clerie	498a429c8d	Explain FieldPOC setup config	2023-10-14 18:19:49 +02:00
clerie	73c2aff0af	Extend OMM setup	2023-09-16 23:13:45 +02:00
clerie	da0df6bab4	Warp docs in a mkdocs website	2023-09-15 18:00:18 +02:00
clerie	cc43776e6d	Add some docs	2023-06-18 22:19:30 +02:00
clerie	3519bdcec4	Add NixOS modules	2023-06-18 21:51:21 +02:00
clerie	6825ba8156	Fix handling of temp extension data	2023-06-18 16:04:21 +02:00
clerie	ca9c82dd59	Prevent crashing on exeptions during reload of extensions	2023-06-18 15:28:53 +02:00
clerie	e51cf2fc48	Use extension attributes in DECT thread	2023-06-18 15:27:06 +02:00
clerie	6c391dc9bb	Wait after exceptions to slow down retries	2023-06-17 22:38:23 +02:00
clerie	e598684837	Do not commit nix build products to git	2023-06-17 20:55:44 +02:00
clerie	f6eefbfc8e	Updating ywsd dependency	2023-06-17 20:51:05 +02:00
clerie	0b30cb2bc7	Retry after failing DECT tasks	2023-06-17 20:18:54 +02:00
clerie	ff480cb8b5	Add flake	2022-10-16 10:43:13 +02:00
clerie	710d68268f	Don't allow extensions to be a prefix of other extensions	2022-09-03 08:58:24 +02:00
clerie	6a227b4dce	Move extensions.json file path to config file	2022-09-02 22:03:38 +02:00
clerie	d72ff01372	Refactor extensions parsing	2022-09-02 21:51:55 +02:00
clerie	ba0d687b63	Refactor thread handling	2022-09-02 21:07:39 +02:00
clerie	035576dff0	Fix json syntax	2022-09-02 20:43:58 +02:00
clerie	557ed051d6	Describe system architecture	2022-09-01 13:33:27 +02:00
clerie	9a84809984	Rename reload_config to reload_extensions to make clear what it really does	2022-08-27 16:16:24 +02:00
clerie	e840ec0afc	Explain the use of sipsecret	2022-08-27 16:14:20 +02:00
Ember 'n0emis' Keske	3a113c9baf	try to fix sqyalchemy-error wieh deleting a forkrankmember	2022-07-27 14:12:02 +02:00
Ember 'n0emis' Keske	2f1347f341	allow to claim extensions	2022-07-20 23:39:58 +02:00
Ember 'n0emis' Keske	4382942ad8	sync after creating temp-extensions	2022-07-20 15:44:11 +02:00
Ember 'n0emis' Keske	d6d664b469	do more dect sync stuff	2022-07-10 13:04:20 +02:00
Ember 'n0emis' Keske	a444e41787	routing: save ids when adding to database, use correct queue	2022-07-10 12:40:05 +02:00
clerie	c2ef36c5a7	Add missing dependencies	2022-07-06 14:45:37 +02:00
clerie	4253a39684	Extend readme with setup documentation	2022-07-06 14:04:13 +02:00
clerie	548f6beb9f	Add packaging	2022-07-06 13:33:31 +02:00
clerie	9394f6376b	Integrate call routing management	2022-07-06 13:15:31 +02:00
clerie	f016f78902	Integrate ywsd	2022-07-06 13:05:06 +02:00
clerie	67d8243526	Add license	2022-07-06 01:50:58 +02:00