Posts by tag : AEM

Recap. rsync for AEM

rsync for CRX! Recap is based on the ‘vlt rcp’ command, but focuses on providing a simple web interface for syncing content between CRX instances, using a browser or a command-line tool like curl.

Carty

Carty is an integrated tool to create, edit, review and test Sling mappings for Adobe CQ/AEM. Read more.

  • mapping generator - enter domain and the content path and Carty will take of everything else,
  • mapping editor - edit, move, create and delete sling:Mapping entries,
  • tester - check what will be the result of the map or resolve operation,
  • highlighter - Carty explains which entries have been applied to a specific part of the tested URL,
  • configuration - you may choose any path to create mappings, it doesn’t have to be the mapping root currently set in the Resource Resolver

CRX Content Package Deployer Plugin

Deploys content packages to AEM applications.

  • Supports password-less HTTP Signature authentication using your configured SSH Private Keys, eliminating the need to coordinate password exchange between developers, devops, and operations teams.
  • Downloads and/or deploys 1-to-many CRX packages per execution, and deploys each CRX package to 1-to-many servers per execution
  • The multiselect-enabled Package Choice Parameter allows for execution of parameterized builds using a selection widget populated with a list of packages retrieved from a CRX server.

Jackalope - A fake Jackrabbit

An in-memory implementation of the JCR with stubbing capabilities for Apache Sling and AEM objects (e.g., Pages). Provides a nice fluent builder so that your stubbing code visually reflects the JCR structure you are creating.

Client Librarian

The Client-Librarian is a dependency management mechanism for client side libraries (css, js, less) which builds on the concepts introduced by the AEM Client Library mechanisms.

  • Declare Component and Template dependencies on Client Libraries
  • Declare dependencies between Client Libraries
  • Produce .css and .js files which are relevant to the components on a page
  • Use global LESS variables and mixins in your LESS workflow without external compilation
  • Produce multiple brands of .css and .js without unnecessary code duplication
  • Provide programmatically generated or environment specific content for .css and .js

CQ Unix Toolkit

CQ Unix Toolkit is a set of POSIX shell tools that calls curl and other 3rd party commands to perform some different tasks on Adobe CQ platform such as:

  • Create, Build, upload, list, download, install and deletion of CRX zip packages
  • Maintenance tasks: consistency checks, TarPM compaction and index merge, DataStore garbage collection
  • Clear/invalidate dispatcher cache for subtree specified by /statfilelevel
  • Active workflow instances list
  • Display OSGI bundles list and start/stop specified bundles

Each action is wrapped in separate stand-alone script with additional usage output that allows to perform these tasks easily.

AEM Developer Chrome extension

Chrome extension for AEM developers. A collection of tools and links to help the daily AEM developer work a little faster. It’s a work in progress. Please feel free to provide feedback on my little side project.

Prosper

Prosper is an integration testing library for AEM (Adobe CQ) projects using Spock, a Groovy-based testing framework notable for it’s expressive specification language. The library contains a base Spock specification using an in-memory repository for JCR session-based testing and also includes basic Sling request and resource implementations for testing interactions between CQ objects.

  • Test AEM projects outside of an OSGi container in the standard Maven build lifecycle.
  • Write test specifications in Groovy using Spock, a JUnit-based testing framework with an elegant syntax for writing tests more quickly and efficiently.
  • Extends and augments the transient JCR implementation provided by the Apache Sling Testing Tools to eliminate the need to deploy tests in OSGi bundles for most testing scenarios.
  • more…

OSGi Bundle Status Maven Plugin

The OSGi Bundle Status Maven Plugin is used during the install phase of the build lifecycle to check the status of one or more bundles in an OSGi container, such as Apache Felix. The plugin expects the OSGi container to be running at build time in order to connect and perform the check remotely. A typical use case for the plugin would be to verify that an OSGi bundle that is deployed by the project is running as expected after a successful build.

See the project site for the User Guide and project details.

Bedrock

Bedrock provides a sturdy foundation for bootstrapping and simplifying for AEM projects. This library contains common utilities, decorators, abstract classes, tag libraries, and JavaScript modules.

See the project site for the User Guide and project details.

AEM Dash

Collection of Cognifide tools that can help development rapidly. Provides search everywhere engine for AEM platform.

CQ Actions

CQ Actions is a mechanism serving as the underlying transport layer, which ensures that data is properly and safely transported from publishers instances to author instance and is processed on the second one.

ACS AEM Samples

This project is a collection of sample implementation of the various, common building blocks for AEM-based applications.
The samples in this project are not intended and should never be installed on AEM instance directly and only used for reference purposes.
These samples have not been tested for functionality; please report and bugs/incorrectness to the ACS AEM Samples GitHub Issues project.
See full index

SecureCQ

Secure CQ is a tool which can be used to find the most popular security problems in your CQ instance. It tests both instances (author, publish) and also the dispatcher, as some resources should be restricted in the cache configuration. It checks:

  • if the default passwords are changed,
  • if there are no unnecessary protocols enabled after being published,
  • if the the administrator console access is disabled,
  • if content-grabbing selectors are restricted on the dispatcher,
  • etc.

Maven CRX Plugin

This is a plugin designed for Maven 2.x+ based builds to automate CRX compliant packages deployment. It allows to set up upload and install commands as a step in a build process speeding up entire development cycle.

On CQ 5.5, it also simplifies package deployment process by providing a goal (crx:activate) for one-step installation of packages on all publish instances (provided that replication agents are properly configured).

AEM Rules for SonarQube

AEM Rules for SonarQube is an extension for SonarQube which implements a number of AEM/Sling-specific static analysis rules to catch common programming errors.

Sling Dynamic Include

The purpose of the module presented here is to replace dynamic generated components (eg. current time or foreign exchange rates) with server-side include tag (eg. SSI or ESI). Therefore the dispatcher is able to cache the whole page but dynamic components are generated and included with every request. Components to include are chosen in filter configuration using resourceType attribute.

When the filter intercepts request for a component with given resourceType, it’ll return a server-side include tag (eg. <!--#include virtual="/path/to/resource" --> for Apache server). However the path is extended by new selector (nocache by default). This is required because filter has to know when to return actual content.

Components don’t have to be modified in order to use this module (or even aware of its existence). It’s servlet filter, installed as an OSGi bundle and it can be enabled, disabled or reconfigured without touching CQ installation.

Sling Caching Filter

Cache bundle is a OSGi bundle that provides caching mechanisms for pages, components or parts of code. Cache bundle uses it’s two main components to perform those tasks: cache filter and cache tag.

AEM Groovy Console

The AEM Groovy Console provides an interface for running Groovy scripts in the AEM container. Scripts can be created to manipulate content in the JCR, call OSGi services, or execute arbitrary code using the CQ, Sling, or JCR APIs.

For more information on the Plugin and its usage, please see the CQ Groovy Console site

Slice

Slice is a framework which simplifies Sling/Adobe AEM development by using dependency injection pattern (DI). It glues Sling and Google Guice together, allowing developers to create a code with a clean separation of concerns. You can map resources to Java models seamlessly and thanks to DI arrange your application in easily testable and maintainable code.

Slice-CQ56 (Slice plugin)

This is Slice Add-on which extends Slice functionality to support CQ version 5.6.
Slice is a framework that glues Sling and Google Guice together. It eases mapping between resources to classed and to using dependency injection inside Sling and CQ applications. Slice repository: https://github.com/Cognifide/Slice-CQ

Slice-AEM60 (Slice plugin)

This is Slice Add-on which extends Slice functionality to support AEM version 6.0.
Slice is a framework that glues Sling and Google Guice together. It eases mapping between resources to classed and to using dependency injection inside Sling and AEM applications. Slice repository: https://github.com/Cognifide/Slice

Slice-CQ55 (Slice plugin)

This is Slice Add-on which extends Slice functionality to support CQ version 5.5.
Slice is a framework that glues Sling and Google Guice together. It eases mapping between resources to classed and to using dependency injection inside Sling and CQ applications. Slice repository: https://github.com/Cognifide/Slice-CQ

Canary

Canary is a framework that enables simple monitoring of OSGi components and services. The Canary API provides a set of interfaces and annotations that quickly enable developers and engineers to peer into critical aspects of their system. Canary does this by collecting data from registered, monitored services and distributing that data to notification agents, poll response handlers, and persistence services. Canary also aims to reduce outage response and investigation by escalating log levels for problematic services and informing necessary parties of precisely where an investigation might begin. Lastly, Canary provides a clean, responsive UI for viewing collected data and other metrics, in addition to exposing data via JMX beans.

See the project site for the User Guide and project details.

AEM Groovy Extension

OSGi bundle containing Groovy builders and metaclasses for AEM (Adobe CQ). The bundle exposes an API to implement extension “provider” services to register additional Groovy metaclasses in the container.

Sightly Specification

Sightly is the new HTML templating language introduced with Adobe Experience Manager 6.0.
This is the Sightly Specification that defines the syntax and the behavior of the language.
A Java-based reference implementation was donated to the Apache Sling project and can be checked out from https://github.com/apache/sling/tree/trunk/contrib/scripting/sightly. The Technology Compatibility Kit can be run on implementations to check their compliance with the specification. An implementation of version 1.1 of the language specification will be made available in AEM 6.1.

AEM SEO Extension (classic UI)

The SEO Toolbox provides a UI widget that guides authors to optimize their pages for search engines. Since the list of potential criteria for SEO can be arbitrarily long, the SEO Toolbox is built with pluggability in mind. Each plugin, called an “SEO Tool” can contribute a number of criteria that an author needs to check and it can provide a UI to help fix any problems that were detected.

AEM hybris integration extensions

This project shows how to extend/customize the Hybris connector to achieve the following:
* Parse some custom Hybris data when importing products from Hybris: MyResponseParser#parseProductData
* Import product references from Hybris: MyResponseParser#parseUnknownProductAttribute
* Add/update some specific product attributes in CQ when importing products from Hybris: MyImportHandler#updateProduct
* and more…

Sightly TodoMVC Example

This example shows how to build components in AEM 6 with Sightly. It’s a feature-complete implementation of the famous TodoMVC exercise, which is traditionally meant for client-side JavaScript frameworks. This implementation though shows how such an application can easily be built in AEM and it’s status persisted on the server using the Apache Sling REST framework.
All in about 300 lines of server- and client-side JavaScript code, following the latest AEM best practice!

AEM Brackets Extension

Sightly is the new HTML templating system introduced with Adobe Experience Manager 6.0. The AEM Brackets Extension provides a smoother development workflow for writing AEM components, offering several features like:
* Sightly syntax-highlighting;
* code-completion for Sightly expressions, data-sly-* block elements and Use-API Java objects;
* bidirectional synchronisation.

AEM Project Archetype

Maven template to create a new AEM project as starting point to develop your own functionality.

mvn archetype:generate \
 -DarchetypeGroupId=com.adobe.granite.archetypes \
 -DarchetypeArtifactId=sample-project-archetype \
 -DarchetypeVersion=7