en-us/about_psframework.help.txt
|
TOPIC about_psframework SHORT DESCRIPTION Gives an overview over the components that make up the PSFramework LONG DESCRIPTION When scripting for our everyday work, we often end up doing two things: - Implement the same functionality again and again (Example: Logging), because it either isn't worth the effort or we simply don't have the time to do it right, once. - Think "Wouldn't it be cool to have this feature?", then get back into the reality of deadlines and overwork While there is probably no way an outsider can help you with company- specific challenges, this framework is designed to bring you a rich toolkit to deal with the generic scripting issues. Its two main goals in specific are: - Speed up your development, by providing a solid framework of tools to build upon - Provide a manageability to your code The module consists of several component parts: - Configuration : Provide self-documenting settings with input validation and change events - Flow Control : Designed for modules, provide a managed way to handle exceptions and how they are presented to the user - License : Centralize license registration - Message : Powerful logging system, gives flexible control over what message goes where - Result Cache : Allows caching the output of a function, enabling access to its contents, even when the user forgot to store the output in a variable - Runspace : A system that manages runspaces in a peculiar fashion: It guarantees that there is a single copy of the runspace you start #-------------------------------------------------------------------------# # Configuration # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_configuration Key Benefits: - Avoid hardcoding information - Selfdocumented settings that carry their own validation and reaction to change The configuration system is a system designed to store and retrieve settings. On the surface it has similarities to variables, in that it maps names to values. However, there are a few key differences: - No scopes: The same value is the same value. Always - Shared across runspaces: All runspaces have access to the same data - Documented: Each setting can contain a description of what it does - Input Validation: Each setting can flexibly validate its changes - Update events: Changes in value can trigger scriptblocks in response This makes it particularly apt at centrally storing and revealing information that would otherwise have been hardcoded somewhere. A few Examples that will show the basic usage: # Retrieve entire configuration element Get-PSFConfig -FullName 'psframework.message.info.maximum' # Update with valid value Set-PSFConfig -Name 'psframework.message.info.maximum' -Value 5 # Update with invalid value Set-PSFConfig -Name 'psframework.message.info.maximum' -Value 'foo' While manipulating existing configuration entries is simple, creating new ones is slightly more involved, for which it is recommended to read the full article on the configuration system first. #-------------------------------------------------------------------------# # Flow Control # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_flowcontrol Key Benefits: - Integrate error handling into logging - Manage function termination - Hide exceptions from users but make them available to scripters The target audience for this feature are module developers that want to make using their modules more userfriendly. It provides tools to uniformly suppress exceptions but provide opt-in mechanisms for cases where exceptions rather than warnings are needed. The basic issue this component tries to solve, is the fact that beginners will not process and understand exceptions, but removing them completely brings issues with scripts (which no longer can use try/catch). This is the compromise, bringing exceptions via opt-in. #-------------------------------------------------------------------------# # License # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_license Key Benefits: - Provide central, manageable store for license of used products The license system allows a module to easily register the license terms for itself and component it uses in a central location. This makes it easier to discover what licenses are currently in use, as it no longer is necessary to parse directories for license texts. #-------------------------------------------------------------------------# # Message / Logging # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_message Key Benefits: - Easy logging / log management - Logging with automatic logrotate - Configurable and manageable logging - Configurable and manageable script verbosity - Enhanced debugging tools When importing this module for first time in a process, it will start a runspace in the background that will perform the logging. This allows all logging to be performed independent of the function/script that wants to log something, removing disk I/O as a bottleneck. Adopting this system is trivially simple: # Previous code: Write-Host "Some text" Write-Verbose "Some verbose text" # New code: Write-PSFMessage -Level Host -Message "Some text" Write-PSFMessage -Level Verbose -Message "Some verbose text" This will cause the same message to be written to host or verbose respectively. They will also be queued for logging. It is possible to dig much deeper and discover the deep debugging features integrated into this system, but simply replacing your common message handling calls (see above example) is all it takes to get started with benefiting from this component. #-------------------------------------------------------------------------# # Result Cache # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_resultcache Key Benefits: - Cache the last result in a uniform way - Improve user experience by forgiving forgetting to store results in variables This provides a standardized way to 'remember' the last output of a command. Often PowerShell users forget to save the output in a variable. In case of lengthy queries, this could introduce a long wait that was not necessary, when the information is still needed after all. If the command was a function that changes things, it may not even be possible to repeat the execution. In cases like that, having the original output still available helps. This must be implemented in the function that is generating the output, by calling the function 'Set-PSFResultCache'. Retrieving the information for the user is as simple as calling 'glr', the alias for 'Get-PSFResultCache'. #-------------------------------------------------------------------------# # Runspace # #-------------------------------------------------------------------------# Main Article: Get-Help about_psf_runspace Key Benefits: - Manages named runspaces for background tasks - Prevents multiple copies being executed in parallel This component runs a script in parallel to the main code execution. This script must be registered by name, the system will prevent multiple copies to be executed in parallel. This allows a module to create a maintenance script that will run in parallel, without: - Having to implement this parallelism. - Having to worry about multiple copies to run in parallel (so issues such as conflicts when accessing a file are avoided) - Having to worry about doubling the number of runspaces when the module is used in parallel operations. KEYWORDS psframework |