Domino on Linux/Unix, Troubleshooting, Best Practices, Tips and more ...

    Notes Domino Platform - What is Notes/Domino and what is special about it?

    Daniel Nashed  10 January 2019 22:26:42

    In the last couple of month I did workshops with customers to check where they are with their Notes and Domino environment and what they are going to do in the future.

    My part was to explain what Notes/Domino really is and why this is so different than other application platforms.

    Based on my workshop and the presentation I put together a summary. If you want a copy of my German workshop slides, drop me a note.

    The following gives you a high level overview of Notes/Domino which describes the basic architecture and some of the most important core features.

    It is not a complete list of functionality nor describes all the details but it gives you an idea about the concept behind it.

    There is an interesting new Forrester study "The Total Economic Impact™ of IBM Domino" which provides some additional background.

    My summary is more a technical summary that gives you an idea about what is great about the platform.
    And this is not including the new exiting new development options introduced in Notes/Domino 10 which we should look into separately.

    -- Daniel


    When Notes was first released most of the core functionality was already in place and the core architecture never had to change because it was from ground up designed in a way that makes it very flexible, robust and secure.

    Looking into the first memorandum written by Mitch Kapor you can already see the most important aspects and the core idea behind Notes -->

    Later there was a very interesting book published by Lotus Oktober 2000 which is still available. It describes the architecture and core components in a way, which has never been published before or after.

    The foreword already describes the core idea behind the product in a few words.

    „In 1989 Lotus Notes® made the world a little smaller.
    Since its first release, Notes™ has enabled teams of people to work together, even when separated by great distances or when individual contributions are made at different times.
    .. Notes continues to evolve innovative, new capabilities that support its initial core concept: Collaboration made possible through shared, secure, online databases."

    (Source :

    Today we are used to work in shared teams in different countries and timezones but when Notes was first designed there wasn't a wide spread network that everyone could use.

    I recall the times where our servers had modems and later ISDN cards to communicate. Times changed but the concept behind it is still modern and very powerful.

    And when it comes to an integrated, rapid application development platform there is stil no comparable product on the market.

    What is IBM Notes

    When we look into the basic concepts behind Notes/Domino we see a  very flexible, document oriented. none-relational databases system (today you would name it "NoSQL").

    It is a Rapid Application Development & Deployment platform with integrated development and run-time environment.

    Lotus integrated email/calendar functionality into the base environment on same infrastructure and APIs

    Thus extendibility, customization of functionality and design is part of the core product.

    Notes and Domino has support for @Formula, Lotus Script/Com, Java, Javascript and C.

    This includes integration options like own servertasks or even Extension Managers, client extension points

    All of this has been designed into the product since day one.

    The application is document centric with flexible fields and field types per document (including Richtext and MIME).

    So you can have any number of fields of any type in any document. There is no fixed structure that limits you to a certain structure.

    It is not the best choice for large number of often changing records/documents that have more relational structure.

    But you can integrate via ODBC, JDBC and today with flexible Web-Services/REST services.

    Notes/Domino separates UI/Design/Code and Data which is also still a modern approach.

    Leveraging simple but very flexible and powerful architecture: e.g. "forms, views, folders, agents" you can write and extent applications flexible and in rapid application development style.

    The NSF storage (Notes database) holds the design and data at the same time. Both use separated but very similar "note-types" in the database.
    This makes easy to replicate among servers and clients. And this also helps to maintain the design leveraging "templates".

    Notes/Domino supports XML since Version 5 and allows to export/import documents and also design elements!

    The own client/server communication protocol "NRPC" allows transparent client/server access which allows you to work with the same database either on-line on a server or on a local instance "replica" of the database.

    For that reason Notes/Domino has build-in replication for Notes databases between clients and servers with full local support for databases.

    At the time Notes was first releases there wasn't any central directory.

    So Notes/Domino invented an integrated directory containing information for users, groups, servers and other information.

    Domino was one of the first products to support external access and sync via LDAP. And there are also other interfaces to access directory data.

    Today integration with central directories like Active Directory is important. There are multiple options to integrate and sync and also for Single Sign On (e.g. SAML or Kerberos).

    Out of the box you can open, edit and save back attachments with external applications like Office and other applications in any document.
    In addition the Notes client offers optional MAPI support for Office applications for mail integration for local applications.

    One feature that has been taken for granted by many users and developers is the integrated, performance optimized full text index for server and also local databases!

    You can use it in any database and you can use it on Lotus Script. Java and also C-API level!

    The tight integration with email and the private public key infrastructure allows to build flexible work-flow applications where you can digitally sign documents.
    Tight integration means that all functionality is available in one application in contrast to other applications that need separate products to implement comparable functionality -- if other products support the same functionality at all.

    In many cases you end up having multiple other application platforms depending on the solution you choose.

    Development Platform

    Since Version 8/8.5 Notes integrates with the Eclipse development and run-time environment.

    This offered new integration points and application options while keeping all existing functionality from the C/C++ application platform.

    At the time it was introduced this was a good idea. But using Eclipse was quite challenging specially from performance point of view.

    Today we see a move away from this integration and we will probably see other client options soon.

    The development platform (Admin/Design Client) has low footprint on normal desktop with local or server based applications.

    One simple but very powerful part of the application platform is the formula engine which can be used in forms, views and folders to calculate information that is displayed or stored in the application.

    This is is comparable to the @formula uses in spread sheet applications (no wonder looking into the roots of the inventors working on Lotus 1-2-3, Lotus Symphony and earlier products).

    This is on one side a very simple but also a powerful and very effective way to process and present data.

    Full Upward Compatibility

    From the very beginning Notes was design to be upward compatible!

    So all functionality remains supported in a newer version without much modification needed.

    A new version might come with a new On Disk Structure (ODS) which brings new database back-end functionality.

    Clients and servers encapsulate the ODS details for the local NSF so even earlier clients can access servers with later versions.

    Once you updated the client and server code you can simply update the ODS with standard tools/maintenance compact servertasks.

    Updates -- even major releases -- are simple without data migration or export/import!

    Custom applications usually work without or with little modification on new major release.

    Standard unmodified applications are "just" updated via updated templates by the standard design servertask.

    The client UI is consistent cross versions, even when new functionality is added.

    But on the other side this means UI/design enhancements for your existing applications and application maintenance is often neglected because everything just works.

    In fact many applications worked for years without any change. That's why nobody touched them even for UI modernization.

    JVM Support

    It took quite a while until IBM decided to implement JVM 1.8 in Domino and they implemented just in time before Oracle stopped supporting JVM 1.6.

    But  we now have JVM 1.8 support since 9.0.1 FP8 (runtime) 9.0.1 FP10 (compile time)

    An IBM JVM Team provides JVM based on Oracle JVM which is updated in every FP to the latest version available.

    Notes/Domino Security

    Flexible databases access with multiple levels is integrated part of the database design since day one.

    - Manager/Designer, Editor/Author, Reader, Depositor with additional roles

    - Access on document-level with simple but effective mechanisms like Reader/Author fields with names, groups and roles

    - Encryption on field/document level and local database level

    - Execution Control List (ECL) for detailed controlled for signed application code!
    - Integrated Public Key Infrastructure (PKI) document/email encryption based on RSA technology

    - Native S/MIME integration (public certs need deployment process, most customers use gateway encryptions)

    - Certificated based authentication via Notes.ID

    - Access via Certificate and optional password checking

    - Since Domino 8.5 simplified Notes.ID management via "ID-Vault"

    - HTTP via user/password with native SSO (LTPA token, also used in other IBM products)

    - Optional Authentication via X.509 Certificate

    - Optional Authentication with SAML 2.0

    Current Encryption Standards

    - HTTP/ SMTP, LDAP, IMAP, POP3 use current encryption like

    - TLS 1.2 with ECDHE Ciphers (since 9.0.1 FP4) and SHA256 certificates
    - SSL-Labs „A“ Rating

    - Notes NRPC Port Encytion (9.0.1 FP8)

    - Encryption using AES-128 CBC /  AES-128 GCM / AES-256 GCM / RC2-128

    - Ticket Algorithm HMAC-SHA 1 - HMAC-SHA 512 (Default: HMAC-SHA 256)

    - Notes data encryption AES 128 or AES 256

    HTTP/HTTPS Support

    Any database can be presented in web. Web representation with current technologies for example via XPages "Responsive-Design" with responsive design, infinite scolling etc

    - Hybrid applications with Web/Notes Client/mobile access

    - New modern web interface for mail.

    - Verse on Prem (VOP) does currently use a simple add-on installer and leverages the existing infrastructure

    - REST Interfaces for read/write with specific rest services for mail, calendar etc

    - Strategic use of REST with Open Standard documentation with new functionality in the latest Feature Packs

    Domino 64bit Support

    Domino supports native 64bit on all platforms.

    64bit has benefits specially in virtualized environments because it allows better optimization if all components leverage 64bit architecture.

    Larger memory support is also helpful for special applications servers like Traveler, specific HTTP work-loads or the IBM Enterprise Integrator.

    Domino as an application usually does not need more than 4 GB RAM for a normal server configuration.
    IBM put a lof of energy into I/O optimization. There fore not more RAM is needed by the application.

    You would still can benefit on larger memory configurations where the OS will leverage the file-system cache (specially in virtualized environments).

    But the existing code is performance and resource optimized and does not need more RAM on it's own like other applications do.

    64 GB Database Limit

    64 GB remains the physical limit of a Notes/Domino database

    But there are many options to optimize databases to either

    a.) reduce the storage needed
    b.) move some data outside the physical NSF file

    Document Design/Compression → Reduces Design and Document data (everything that is not Index or attachment) up to 50%

    DAOS (Domino Attachment and Object Services) = External Storage for "attachment" data (database objects are move to the DAOS storage)
    Leveraging DAOS officially supports 1 TB per NSF database. Usually for mail-databases attachments would cover 70% of the mail-data.

    NIFNSF = Put view/folder index to a separate file (.ndx) → Maximum size of the .ndx file: 1 TB!

    So when leveraging those technologies the physical limit of the NSF does not matter any more on server level.

    In addition a single NSF file would only hold data for a single mail user or a single application. So the 64 GB is per Notes NSF.

    On client side the 64 GB limit still applies because the optimization is not available in Notes 9.0.1.

    But on the other side more than 64 GB of data in a single application on client side might not be the best idea.

    Domino offers integrated archive functionality which would help to reduce data on the archive mail database or other application databases.

    For Notes/Domino 10 the maximum physical database size is increased to 256 GB.

    Database Optimized Storage

    Leveraging Database Compression, DAOS and NIFNSF also helps your to optimized performance and helps you to reduce storage and backup space dramatically!

    With Document/Design Compression you save additional storage space.

    It is transparent to the application with up to 50 % of data and design reduction just by enabling the feature via standard compact


    Domino Attachment and Object Services (DAOS) moves attachment data to a central store with one file per attachment (configurable threshold usually 256 KB generating NLO files with the attachment) where it is stored deduplicated.

    In addition to deduplication and NSF data reduction you can store data on a NetApp or other technologies which allow deduplication on storage container level to further reduce storage needs.

    DAOS also allows to reduce backup costs leveraging online, incremental backup. The NLO is only stored and backuped once per server!


    A quite new feature introduced in Domino 9.0.1 Feature Pack 8 allows to store the index in a separate file for performance reasons and also to further reduce backup costs.

    The separate file on disk allows optimized locking and the NIF index does not need to be backuped.

    Domino Clustering

    Application level Active/Active Clustering with separate, independent server instances with separate storage

    No SAN mirroring or special storage environment required.

    The Notes Client is "cluster aware" with automatic fail-over and fail-back

    A cluster replicator servertask is used for almost real-time replication.

    Downtime is minimized downtime because maintenance is performed on each server separately and Domino clusters are operating completely independent!

    A single databases can also be taken off-line. The key here is that Domino as a "service" is hight-available and the individual servers can be down for planned maintenance.

    Domino Transaction Logging/Backup

    Transaction Logging is fully integrated into Domino NSF infrastructure since Domino 5.0

    Ensures database consistence and performance for each NSF file.

    Fast restart without fixup after failure (similar to journal file-system on Linux).

    Translog functionality has been derived from DB2 functionality.

    Dedicated backup API interface used by 3rd parties for on-line backup without downtime

    Full backup/Incremental backups with Point in Time recovery per NSF file

    Notes Domino Diagnostic & Fault Recovery

    Outstanding, fully integrated diagnostic functionality for crash, hand, memory leaks etc.

    NSD (Notes System Diagnostic) provides detailed diagnostic information for IBM to pinpoint and fix issues.

    Fault-Recovery provides fast restart after server crash

    Automated diagnostic collection (ADC) after restart collects diagnostic data from client or server.

    Mobile Mail/PIM Access

    „Mobile First“ is one of the important IBM strategic goals.

    IBM Traveler as a separate, easy to install solution leverages the standard Domino server stack.

    Mobile access via iOS, Android, BB10 for Mail, Calendar, Contacts (and Todo)

    Native Verse Client (App) for iOS and Android via SyncML

    iOS Mail App Support via Active Sync

    BB10 Support via Active Sync

    My Conclusion

    Today mail is commodity. Notes and other products support similar features compared to other platforms.

    Replacing Notes as a mail-platform alone does not provide much benefit and has migration risks and costs.
    Specially coexistence during the migration or with existing applications can be tricky.

    The key benefit for Notes/Domino as a platform is unmatched rapid application development.

    There is no easy way to migrate applications and if you end up replacing just part of the applications you have to support and pay for both platforms for a longer time period.

    Alone the full integration of application with mail, calendar and contacts and workflow functionality is difficult to replace by one single product.

    Customers migrating most of the times have to move applications to multiple platforms and write new applications.

    Notes/Domino is stable, integrated, performing, high available platform.

    It has good TCO as an application platform compared to other platforms. There is no single platform providing all functionality used by customers today.

    In addition today offers Domino REST APIs to be more flexible and used in a micro-services landscape and can be even better integrated with other enterprise applications.

      Happy New year and a good start into a successful, happy and healthy 2019!

      Daniel Nashed  2 January 2019 18:03:32

      The last year got us some surprises. After Domino 10 was launched IBM and HCL announced that HCL will completely take over most of what was Lotus/IBM Collaboration.

      I think this is great news and a very positive move. Neither IBM nor HCL cannot reveal all details of the deal due to some legal requirements.

      But this link is a good starting point for current information from HCL side -->

      They will launch a partner program this month and we are looking forward to it. So I am looking forward to news in the next couple of weeks.

      And HCL is also working already on Notes/Domino/Traveler 11 while they are collecting more feedbacks having world wide jam events again along with the idea website -->

      I have also been selected another time as IBM Champion for ICS.

      It's great feedback that my work is helpful for the community.  And that's the main reason I am very happy about it!
      Probably this will be my last year as a champion but hopefully HCL will have a similar program.

      Being an IBM Champion is a great honor and privilege. It is a recognition of the work I have done in the community!

      For those who do not know what an IBM Champion is, here is a link

      Have a great 2019 and I hope to see many of you again at all the upcoming events this year.


      Notes/Domino 10.0.1 is available for Download

      Daniel Nashed  18 December 2018 16:51:06
      As promised we are getting Notes/Domino/Traveler before Xmas!

      Download was really quick. The release notes don't show in detail was has been added/fixed and I did not see release notes yet.

      From what I understood this will be English only until January 2019.
      But they shipped the Mac client and added the MarvaelClient Essentials.

      There is also a new Traveler 10.0.1 Version but I do only see two fixes in the 10.0.1.
      I would wait for the next Traveler update. I got a hotfix yesterday for testing with some additional fixes.

      The Technote has all the product codes for download from Passport Advantage. I added the SHA1 checksums.

      Here is also an entry point for updated documentation:

      Updated Documentation for 10.0.1

      Download Information

      IBM Domino Server v10.0.1 64 bit for Linux English (CNXL9EN)  / F380BACEE82B68DD0A9D783626E9CA50BCC619B8
      IBM Domino Server v10.0.1 64 bit for Windows English (CNXL7EN) / 9738E1B0862081BA8567E34B8513F867EDAA343B

      IBM Domino Server v10.0.1 64 bit for AIX English (CNXL8EN) / E81035131135374B7C35F34AFD59E862082DBA18

      IBM Notes, Domino Designer and Admin V10.0.1 for Windows English (CNXL1EN) / 5E22B00B2F8DD30B230897C6701FF6DFCC060AE7

      IBM Notes v10.0.1 Mac 64 bit English (CNXK7EN) / 24E3E643875BA5B4AE01A47776870AD06C74AE05

      IBM Notes and Domino v10.0.1 Release Notes English (CNXK4EN) / ADF283889B48F7A812B9113E73F66D523B4E0C4F

      First Technotes

      How to download IBM Notes 10.0.1 from Passport Advantage

      MarvelClient Essentials IBM Notes management solution

      Open Preview collapsed when opening a mailfile for the first time

      Daniel Nashed  16 December 2018 11:51:40
      This isn't a new tip but there have been fixes in 10.0.0.
      The parameter did not work correctly in all situations. I never ran into issues but according to fixlist there have been some issues.

      The parameter is very helpful on admin clients when admins are opening user's mailfiles for support purposes.
      In those cases the preview could for example cause that the first document in focus would be marked as read.

      So notes.ini ShowPreviewCollapsedInitially=1 would make a lot of sense on our admin clients.

      -- Daniel

      SPR# MWID7LWRJ7 - Fixed an issue where the ini ShowPreviewCollapsedInitially=1 would not honor all cases of collapsing the preview pane in the mail inbox.
      Now this ini can be pushed out via policy and handle all cases for primary user or mail file delegate.

      HCL aquires IBM Collaboration products

      Daniel Nashed  13 December 2018 12:30:07
      You probably all have heard about the deal. But there isn't much detailed information available yet.
      HCL had already a development relationship for most of this products. IBM Connections was the big surprise.

      It's a logical next step. For Notes/Domino/Sametime/Traveler and related products (which is the focus of what I am working on) the development team and support including L2 was already working for HCL.
      So all the existing developers working on the product and new developers are hired!  Not only in new locations but also in Chelmsford, MA which is not far away from Westford, MA where the Iris/Lotus development team was located in the early days.

      Now that HCL has a good overview working on Domino 10 as a product they have the confidence in the product to bring it forward.
      The responsible manager for the Products and Platforms division -- the group responsible for all of the collaboration products -- worked for IBM before and has a clear vision why they want those products in their portfolio. And he wants the full control of product strategy for good reasons.

      There is not much public information yet. IBM partners got an e-mail with details about a transition for IBM partners with details which will be more clear in January.
      I asked back about public information that I can share for customers and partners and got a link to a more detailed statement, which I would like to share.

      In this post you find a couple of -- from my point of view -- remarkable statements which all lead to the right direction. Some of those words have never been used by IBM when it comes to their Collaboration products.

      And there is another link for a short profile for the "pnp-hcl" division

      The deal will be executed mid of 2019! So until mid of the year everything remains as it is for customers.
      In the background there might be already changes and they will take some time to prepare. And some of the details can probably not be released in public yet.

      But speaking with customers, partners and also some of the developers, I am confident that this is a very positive move!

      -- Daniel

        Domino Start Script 3.2.0 with Docker Support

        Daniel Nashed  2 December 2018 21:31:29
        Finally I released start script version 3.2.0. After it was almost done I got a request for add Docker support :-)

        Domino on Docker works a bit different than other Linux implementations.
        The current versions sort of use systemd. But it's not completely implemented.

        So the right way to start and stop Domino is to use the entry point of the Docker container.
        The Start Script contains an entry point script that handles the start and stop of the server.
        It works in combination with the rc_domino_script.

        After the server is started, the entry point script waits for the shutdown in a loop.
        When a container is shutdown a signal SIGTERM is send before s SIGKILL is send.
        For a proper shutdown the default shutdown time needs to be extended from 10 seconds to a longer time like 60 seconds with the --time option for the "docker stop" command.
        The entry point catches those signals and does a proper shutdown.

        In addition to this the new install_script routine is Docker aware and installs the entry point along with the start script.

        All components and the new functionality is documented in the readme contains  all the details about the new functionality.

        The start script is now distributed under Apache 2.0 License to allow to include it in other projects like distributing it with a Docker script ;-)

        You can request the new version on the start script here ->

        -- Daniel

        Domino 9.0.1 FP10 IF5 released

        Daniel Nashed  2 December 2018 15:44:55
        There is a new IF5 which has been just released.
        The fixlist shows 5 fixes and some of them could be important for you.
        There are two NIFNSF fixes which appear to be critical.
        Two others are about issues in special conditions when replicating databases.
        And one important fix for compact.

        In contrast to the previous IF4 which I did not blog about, this one makes sense to be installed even if you are not using NIFNSF.

        -- Daniel

        Fix introduced in release
        Additional Information
        Interim Fix 5
        for Domino 9.0.1 Feature Pack 10
        MSKAB56HC9 Fix frequent crashes in GsKit on 9.01FP10 Windows Only
        WSPRAWTJ5N Fix an issue with multiple replicas processing the same connection doc at the same time  
        ROBEAXPFDP Fix an issue with Pull Replication Failing When Run At The Same Time As A Pull/Push  
        OSAMAXAGGJ Fix a server crash when rmflush access the .ndx file while compact was finishing up  
        PMGYAKWECA Fix crashes affected by the use of NIF/NSF in databases  
        OSAMAVSQQL Fix a long held lock when compact is running  
        Interim Fix 4
        for Domino 9.0.1 Feature Pack 10
        DWONB2HL4Q DST 2018 - Brazil - Fix Calendar entries which are off by one hours for two weeks  
        MKENB3MPFY Memory overwrite found in sgml parser casing http/notes client to crash when trying to render a document  
        MKENB3PEBF Backend lsxbe open stream should check for null file name before passing it to OS routines to prevent crash  

        DNUG IBM Domino Mobile Apps Webcast and Slides

        Daniel Nashed  5 November 2018 13:29:41
        There was a very interesting Webcast hosted by DNUG last week where IBM did present the new iPad client.

        We had just a limited number of participants based on the platform that was used.

        But the slides and also the webcast replay has been made public.

        This is a must see presentation and webcast and shows a lot of examples and many details!

        The webcast is in German but the slides are in English.

        Huge thanks Erik Schwalb!!

        And also thanks for the DNUG Mobile Group (Detlev Poettgen) to organize this webcast.

        -- Daniel


        Webcast Replay:

          Official IBM Domino Mobile Apps Beta finally started

          Daniel Nashed  4 November 2018 14:45:39
          Now that the beta is public we can finally show it and you can have a look on your own.
          I wasn't sure I am allowed to speak about it in public. That's why I did not post anything yet.

          Here is the link to the beta registration -->  

          And a link to the beta documentation -->

          When you apply for the beta, you get a TestFlight invitation from IBM which allows you to download and install it.

          Update: The registration changed a bit after the beta went live.
          The pre-registered uses have been queued and we got email notifications.

          When you register today you should follow the link directly from your iPad. Once you filled out the form you are directly redirected to the TestFlight app.

          In the app you don't have to specify a reedem code. You just close the keyboard and scroll down to continue.

          Thomas has a screen print in his blog post to show how it looks like ->

          The client for the iPad is a native application that is intended to run basic client applications which are written in Lotus Script and @Forumlas.

          Just Java code isn't supported because Apple does not allow Java code on iOS devices.

          The application is a separate port based on the client binaries and IBM/HCL are also intending to work on an Android version with the same functionality.

          The app intended to run all your existing apps and brings a rapid application development option for new apps to your iPad!

          Two Apps - Don't be confused!

          There will be two different offerings that will be technically the same app.

          1. IBM Domino Mobile Apps

          This app is intended for customers in maintenance with entitlement to the new client

          2. HCL Nomad

          This app is a separate paid offering from HCL

          Both applications are technically the same. But they will be offered to the market in different ways.

          So the one that is available for beta testing is IBM Domino Mobile Apps.

          Bringing your Notes.ID to the app

          The best way would be to leverage ID Vault. The client is ID Vault enabled and you can deploy your by specifying your name and the correct password.

          If you don't have an ID Vault you have to upload your ID via iTunes which is quite complicated and might only work for admins haven a first look.

          So you should really use ID Vault. In fact I configured ID Vault just for that in my one person production environment (managing the download count manually in my case).

          How does it look & feel

          From the first builds we have seen this looks already great! There is still some functionality still pending like the action/agent menu. But beside that it's already awesome!

          You can replicate applications and you see all the "hidden" features work that are build into @forumula since ever.

          I have played with it and I am accessing some of my more complex applications and it works already very well! Also the newer Notes port encryption has been added which is enabled on my external server.

          You should have a look into it on your own and provide feedback to IBM thru the app.

          There is a menu entry "Report a Defect" which will generate an e-mail.

          Results from some simple Formula-Tests

          Here some interesting results from fom @formulas. This really shows that this is a real client not just a simple app.

          Almost all the @functions I tested worked.


          /var/mobile/Containers/Data/Application/86839C84-8B1A-49D7-ACE9-17EC63747EE6/Library/Preferences/Notes Preferences

          @GetMachineInfo ([EnvVariable]; "Directory")

          /private/var/mobile/Containers/Data/Application/2EC1C196-0F72-4546-ABAA-08120167278C/Library/Application Support

          @GetMachineInfo ([MachineName])


          And you can also try the following two.

          The workspace made it hidden into the app but is not intended to be used right now.
          There are discussions if the new recent applications page or the workspace are better to use. I would say this depends on user's peferences.

          @Command( [WindowWorkspace] )


          Works like expected and returns a database.

          @Prompt([LocalBrowse]; "Select a file"; "1");

          File operations like this ask to take a photo or to select an existing photo.

          In both cases are filename is returned. So there is no direct way to select files on your device, which looks like an Apple restriction.


          You really should have a look into it on your own and get your own impression!

          Everyone has his own view what to test. I am usually trying to figure out how it works in the back-end.
          But in this case I am also interested in how it looks and feels.

          I am interested in your first feedback as well!

          IMHO this is a great new way for application development on an iPad!

          -- Daniel

            Domino Start Script V3.2.0

            Daniel Nashed  4 November 2018 08:38:18

            There wasn't a new release of my Linux/Unix Start Script for a year.
            I still have many download requests but there is not much feedback or feature requests.

            Most of the new functionality added is coming from my own requirements (for example to simplify operations) Or direct customer requests.
            I am always trying to understand the underlying requirement and add it in a flexible way, that many admins can benefit from it.

            The new version I am working on simplifies configuration with systemd. You don't have to change the rc_domino file any more.
            And it comes with a simple installation script that will copy the files for you and sets the right permissions.

            Sadly systemd does not allow to use variables in the way I would need it, to read configuration from a config file.
            So the install script will only work for default configurations where you use the notes user and group with a single partition.
            I wanted to avoid a complex configuration script that replaces variables in the start script files.

            Beside that I also added a couple of commands that make your life easier. You can now list or edit all files involved including the systemd service file.

            And you can also show the log of the server. That's one command that was missing for me.
            Before I already added lastlog where you can show the last n log lines and redirect that for example to a grep command.
            Now you can do whatever you like with the log by specifying an additional parameter behind log (without a parameter vi is used).

            And last but not least I added another way to schedule compact operations.
            You can now configure a one time compact for example after a maintenance boot.

            See detailed feature list below for more information.
            If you have other ideas and requirements that should be in the standard, let me know.

            I am currently testing the new version and will update the start script page soon.

            -- Daniel


            New Features

            New command 'log' -- displays the start script output log.
            This command can be used with additional options like specifying the command to open the log (e.g. 'log more').
            See log command description for details.

            New command 'systemdcfg' to edit the systemd configuration file

            New command 'compactnextstart' which allows you to configure a one time compact at next startup.
            For example after an OS patch day. The new command allows you to enable/disable/display the settings.
            Check the command documentation for details.

            New config variables DOMINO_DOMLOG_DB_DAYS, DOMINO_DOMLOG_DB_BACKUP_DIR which can move domlog.nsf to a backup directory.
            This works like the log.nsf backup/rename introduced earlier.

            New config variable DOMINO_UMASK.
            And also allow to set the umask when starting the server via DOMINO_UMASK.

            Show the umask used in the startup log of the server (along with environment and ulimits etc).

            Separate, simple script 'install_script' that will allow you to install the start script for default configurations.


            Start script is now prepared for systemd without changing rc_domino script (adding the service name).

            Enable the configuration for systemd in the rc_domino script by default and check if systemd is used on the platform.
            This allows to install it on servers with systemd or init.d without changing the rc_domino script.

            Changing deployment from zip to tar format. So you can unpack the files directly on the target machine.
            This also means you can run the install_script without changing the permissions.

            Changed the default location for the Domino PID file for systemd from /local/notesdata/ to /tmp/
            This allows you to change the data directory location without changing the pid file name in domino.service and config.
            But this means for multiple partitions you have to change the name for each of the services.

            I tried to dynamically read parameters from the config file in domino.service.
            There is an EnvironmentFile= statement in systemd services to read configuration files.
            But using variables does only work for parameters passed to a an ExecStart/ExecStop command but not for the name of
            those scripts invoked. Also it is not directly sourcing the parameters but reading them directly.
            So there seems to be no way to read the config of domino.service from the config file.
            And I had to "hardcode" the filenames.


            • [IBM Lotus Domino]
            • [Domino on Linux]
            • [Nash!Com]
            • [Daniel Nashed]