| HTML |
|---|
<style>
.text-span-6 {
background-image: linear-gradient(99deg, rgba(170, 163, 239, .5), rgba(125, 203, 207, .5));
border-radius: 50px;
padding-left: 15px;
padding-right: 15px;
}
#title-text {
display: none;
}
.panelgradient {
background-image: linear-gradient(180deg, #d5def0, whitesmoke);
border-radius: 8px;
flex-direction: column;
justify-content: center;
align-items: center;
padding: 4rem;
display: flex;
position: relative;
}
</style>
<div class ="panelgradient">
<h1 style="text-align: center;">Solution<br>Settings and Tools</h1>
</div> |
Introduction to Solution Settings and Tools
The Solution section in the Designer workspace gathers detailed information about solutions, offering rich metadata and various tools to aid in designing and individually managing solutions on the software platform. It includes Solution Settings for configuration, Solution Categories for organization, Import Tags and Import Plugins to accelerate solution creation, Export for sharing configurations, and History for tracking key actions in the solution configuration.
On this page:
| Table of Contents | ||||||
|---|---|---|---|---|---|---|
|
Key Concepts and Terms
The Solutions section holds key global settings, such as Target Platform, and a set of tools to allow Import and Export configurations.
TargetPlatform
Defines the Operating Platform where the Solution is intended to run. It can be Windows Only (.NET Framework 4.8), or Multiplatform (Linux and any OS support .NET 8.)
Product Family and Model
Define the licensing requirements to run the solution in production. Even though the Designer is unlimited, you should always set up those fields properly so that the Designer will limit its functionality consistent with the license required for field deployment.
Categories
Metadata labels that can be used across all configuration tables, assisting in organizing large-scale applications.
Plugins
Subsets of a solution, which can holds Tags, Displays, or any other objects. Useful to creating reusable components and enforcing development standards.
Understanding The Solution Module Usage
The Solution Module is typically used only when a new Solution is created.
Usually, it is important to double check if the Target Platform, Product Family and Model, are correctly setup. When using Python, its necessary also to locate property the path for the Python engine.
For large solutions, defining the Categories at the begging will prove useful to organize your configuration.
If you have tag definitions available on other systems, you can bring them with the Tag Import Wizards, which support importing from CSV files, ControlLogix devices, and various other options.
Finally, if you have PlugIns created by your own team or received from integrators, they can be added in this section to speed up the solution development.
Plugins are created with the Solution Export user Interface.
When you perform any of these actions, the Solution History tracks the event.
Configuring Solution Settings and Categories
Go to Solution Settings for animation on the settings available.
Go to Solutions Categories to learn how to define and use Categories.
Working with Import and Export Tools
Go to Solution Import Tags on how Import Tag definitions from other systems.
Go to Solution Import PlugIns on how Import PlugIns into the solution.
Go to Solutions Export on how to backup the solution, or create PlugIns
Using the Solution History
Go to Solution History on how to track major Solution events, and update Plugins.
Temporary Data Folders
When editing and running the solution, temporary sub-folders are created under a Solutions-Data folder.
In most cases, it's not necessary to have any direct interaction with these folders, other than knowing they don't store solution configuration — only user UI settings and temporary files. Therefore, they can be deleted at any time if necessary.
→ Read more at Temporary Data Folders.
In this section:
| Page Tree | ||||
|---|---|---|---|---|
|
Introduction to Runtime Environment
The Runtime Environment is the active stage where a Solution operates.
Runtime Environment Involves
- Using of Functional Modules
- Acquiring and Processing Data
- Updating Visual Displays
- Performing Tasks Based on the Solution's Configuration
The Runtime Environment contains all Modules used in the solution configurations. The setup is directed by SolutionExecution Profiles, which guide the solution's connections and actions. The profiles enable the same solution configuration to interface with various databases and devices, accommodating different phases such as Development, Validation, or Production.
On this page:
| Table of Contents | ||||
|---|---|---|---|---|
|
Purpose and Key Concepts
The purpose of the Runtime Environment is to actively operate configured solutions, executing real-time data acquisition, scripts, alarms, and all items from all modules. It represents the essential final phase of solution development, delivering the application's functionality.
Runtime
The term "Runtime" or "Runtime environment" refers to the execution environment, distinguishing it from the Configuration (or Engineering, or Development) phase. "Runtime" also denotes the software components and computer processes that are in execution.
Execution Profile
An Execution Profile are settings that allow customization of database connections and device network addresses. This will allow management of different environments.
→ Read more about Execution Profiles
Online Configuration
This feature allows real-time modifications to a running solution without stopping its execution. Users can adapt the solution to changing requirements, enhancing flexibility and responsiveness.
Hot Updates
Hot Updates are a subset of online configurations that allow the application of offline solution changes without disrupting the runtime environment. They maintain solution stability and prevent downtime, ensuring the solution remains up-to-date with the latest changes.
Build and Publish
The build and publish process involves compiling the solution code and creating a read-only version of the solution for distribution to end-users. This step ensures the solution is ready for deployment and accessible to the intended audience.
Understanding the Runtime Environment
Real-Time In-Memory Database
When the solution is in execution, variables like Tags, Templates, and Assets, are loaded into the memory. These variables act as a central point of reference, allowing other functional modules to request or publish values as they perform their functions. The computer process and executable responsible for maintaining the real-time database is TServer.exe. This application can run as a Windows Service or be deployed to Linux and other supported operating systems.
Startup Procedure
For details on the startup procedure review the SolutionRuntime Startup page.
For details on setting up the execution review the Solution Deployment page.
- Launching TStartup.exe
- Loads the Solutions
- Reads the Solution Configuration
- Parses Command Line Parameters
- Activates the Main Process TServer.exe.
- Starting the Real-Time Database
- TServer.exe starts by loading solution objects, tags, templates, and assets into the memory. A communication service is established, allowing other modules to start and connect.
- Modules Startup
- The other modules, such as Historian, Alarms, Devices, Scripts, Datasets, and Reports, then start their execution by reading the solution configuration and establishing a connection with the main process.
- Applying Execution Profiles
- As the modules start, they behave according to the definitions in the Execution Profiles. For instance, in Development mode, a temporary local SQLite database might be used for alarm records, while in Production mode, the Alarm Database is automatically mapped to a SQL server.
- Solution Designer Automatic Connection
- The Solution Designer automatically connects to the running solution, enabling users to monitor progress, make adjustments, and troubleshoot issues as needed using the Monitor and Diagnostics pages.
- Opening Client-Side Displays
- Operations displays, using HTML5 from any browser or high-performance WPF graphics pages, can be opened from any remote computer connected to the server.
- Applying Online Changes and Hot Updates
- During execution, the system can apply online configuration changes and hot updates without disrupting the runtime environment. This capability allows users to adapt the solution to changing requirements while maintaining high system availability.
Configuring the Runtime Environment
When developing a software solution, maintaining stability and preventing interference between various stages and components is crucial. To ensure the configuration and development aspects do not negatively impact the solution's runtime environment, use "Configuration and Runtime Process Isolation."
The Configuration Process involves setting up parameters, profiles, and other settings that define how the solution should operate.
Isolating these processes allows developers to modify configurations and test new features without disrupting the running solution, defining how the solution should opportunity depending on the Execution Profile you are running.
Runtime Configurations
Runtime Startup
The Runtime Startup section allows you to Start and Stop the execution of the Solution, specify the Execution Profile you want to use, and customize all settings connected within that execution.
The settings defined here are also applied when the Startup is executed by the StartSolution command line, or starting the solution as a Windows Server. This section focuses on the various settings you have available and starting and stopping manually.
→ Read more about Solution Deployment.
Execution Profiles
Execution profiles enable distinct configurations for a single project, facilitating a seamless and swift transition between devices and databases.
Development, Validation, and Production the solution must operate over its lifecycle. Occasionally, these scenarios may overlap, posing risks to the entire operational environment. In this version, we introduce an intuitive method to separate these stages, enhancing both security and reliability.
→ Read more about Execution Profiles
Build and Publish
The software platform offers support to manage solution versions, allowing the creation of a read-only version and a published version. The Build feature compiles the solution's displays and scripts for final verification before deployment in production. It ensures complete verification of an application's scripts in preparation for production. The Publish command generates a read-only protected version of a solution ready for field deployment. This command produces a new Solution file (".dbsln") with the chosen version number. The Published Solutions (".dbrun") mirror the current solution but are accessible only in read-only mode, offering a secure backup of published applications.
→ Read more about Build and Publish
Runtime Diagnostics
This page provides a comprehensive guide on how to use diagnostic tools for project applications. These tools include the Property Watch, Trace Window, and Module Information, which offer insights into the status and operation of different modules within your application.
Property Watch is a tool designed to access and modify the system's tags and internal properties. With an Intellisense feature, it also provides a list of available objects related to a specific object type.
→ Read more about Runtime Diagnostics
TWebServices
TWebServices and TServer are components within the software platform. TWebServices enables external interactions through a web interface and APIs, enabling remote system monitoring, control, and integration with other software. TServer is the backbone for internal processes, handling data exchange and communication between devices and software modules via WebSockets for real-time, bidirectional connectivity. It also manages system configuration and a shared real-time database, supporting the functionalities that TWebServices makes accessible externally, ensuring seamless operation and integration across the platform.
→ Read more about TWebServices
Server And Client Namespaces
There are a few runtime objects that provide information about running the solution.
The Info namespace is the main location for the runtime status. The main objects on the namespace are:
Info.Solution: information about the solution that is running
Info.License: information about the license
Info.Module: information and start/stop command to Modules
Info.Trace(): displays a message on the TraceWindow
Info.TestMode: shows if the solution is running in Test ModeThe Server namespace has information about the server computer. The Client namespace has information about each client compute that runs a graphical interface. See Namespaces for the complete programming reference on runtime objects.
Working with the Runtime
Starting and Stopping the Solution Execution
To start the solution execution, you need to launch the application or server, depending on the solution type. It is essential to monitor the system for any errors or issues during startup, as they may prevent the application from running correctly.
To stop the solution execution, you can use the appropriate command or interface provided by the runtime environment or the application itself. Make sure to gracefully shut down the application to avoid data loss or corruption.
To start the solution in production mode:
- Go to Runtime → Startup.
- Click the Run Startup button
Applying Configuration Changes
Configuration changes can be applied to the runtime environment to modify the behavior of the application. These changes can include modifying settings, adding or removing modules, or adjusting resource allocation. To apply configuration changes, follow these steps:
- Identify the configuration file or settings for your application.
- Modify the configuration settings as needed.
Restart the application or reload the configuration to apply the changes, depending on the capabilities of the runtime environment.
Troubleshooting and Best Practices
Runtime issues can occur during the execution of the application, such as crashes, performance problems, or unexpected behavior.
Troubleshooting Runtime Issues
- Review the application logs for any error messages or warnings.
- Use debugging tools to inspect the state of the application at runtime.
- Monitor system resources, such as CPU, memory, and disk usage, to identify potential bottlenecks or resource constraints.
- Consult the documentation or support resources for known issues and solutions.
- Make sure you're using appropriate execution profiles for different stages of the development lifecycle.
- Apply configuration changes carefully, always testing before deploying to production.
- Document any custom configurations or modifications for future reference.
- Keep the runtime environment up to date with security patches and software updates.
Best Practices for "Runtime Isolation"
- Use Separate Environments: Using separate environments for development, testing, and production allows working on solution configurations and features without affecting the runtime environment. Changes made during development are not reflected in the runtime environment until they have been tested and deployed.
- Use Containers: Technologies like Docker enable developers to create isolated containers for different parts of the solution. This approach ensures that modifications in one container do not impact the runtime environment in other containers.
- Use Version Control: Implementing version control helps manage solution configurations and code changes. This method allows developers to experiment with configurations, roll back to previous versions, and track changes without affecting the runtime environment.
- Use Access Control: Access control mechanisms restrict modifications to the runtime environment and configuration settings. This ensures that only authorized personnel can make changes, reducing the risk of accidental disruptions or unauthorized access.
Troubleshooting Common Issues
Performance bottlenecks: Slow solution execution can be caused by a variety of factors, such as inefficient code or inadequate hardware resources. To resolve this issue, optimize your code, allocate more resources, or employ parallel processing techniques.
Configuration errors: Incorrect settings in the solution configuration can lead to unexpected behavior or failure. Review your configuration files, verify the parameters, and ensure they adhere to the documentation.
Runtime environment mismatch: Incompatibilities between development and production environments may cause issues during runtime. To address this, ensure that all dependencies are consistent across environments and use containers or virtual machines for environment isolation.
Module conflicts: Conflicts between modules can lead to unexpected behavior or crashes. To resolve this, check for duplicate or outdated modules and ensure that your modules are compatible with each other.
Database connectivity issues: Problems connecting to the real-time database can be caused by network issues, incorrect credentials, or misconfigured database settings. Verify the database connection settings, ensure the database server is accessible, and check the credentials.
Client-side display errors: Issues with client-side displays can stem from incompatible browser versions, outdated JavaScript libraries, or improperly configured display settings. To fix this, ensure your solution supports the target browser versions, update your libraries, and double-check display settings.
Hot updates not applied: If hot updates are not being applied correctly, confirm that your solution is configured to accept online changes and verify the update mechanism is functioning as expected.
Build and publish failures: Errors during build and publish processes may be due to incorrect settings, code issues, or dependency problems. Review the build and publish configuration, fix any code issues, and ensure all dependencies are resolved.
What's Next?
→ Unified Namespace (Tags, UDT's)