Overview

eGovernments Foundation transforms urban governance with the use of scalable and replicable technology solutions that enable efficient and effective municipal operations, better decision-making, and contactless urban service delivery.

Our comprehensive software products enable Governments to put their resources to efficient use by minimising overheads. We also help bring transparency, accountability and citizen-centricity to the delivery of Government services.

eGovernments Foundation has been at the forefront of implementing eGovernance solutions since 2003. Our products have been serving over 325 ULBs across the country. Our time-tested products have impacted the ULBs in a large way. We have also been involved in several eGovernance initiatives in the country.

Our primary business motivator is to increase the footprint of eGovernance across the country and help adoption in as many ULBs as possible. Going open source with our products is a measure in this direction. It also gives us the ability to tap into the immense talent pool in India for strengthening and improving our cities. Open source also blends well with our ethical fabric of being open and transparent in our business.

Issue Tracking

Report issues via the eGov Opensource JIRA.

License

The eGov suit is released under version 3.0 of the GPL.

Powered By

(https://gitter.im/egovernments/eGov?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Software Architecture Diagram

Refer to the software architecture diagram below:

Overview

This page provides the steps that are involved in building and deploying the application.

Build Stages

1. Checking out code from GitHub

2. Maven build process (includes the Junit tests)

Apache Maven - to manage dependencies for projects. Maven can be installed as a command line tool.

Creating Artifacts (EAR) On Successful Build Process

An artefact is an assembly of any project assets that you put together to test, deploy or distribute your software solution or its part. Examples include a collection of compiled Java classes or a Java application packaged in a Java archive, a Web application as a directory structure or a Web application archive, etc.

An artefact can be an archive file or a directory structure that includes the following structural elements:

1. Compilation output for one or more of your modules

2. Libraries included in module dependencies

3. Collections of resources (web pages, images, descriptor files, etc.)

4. Other artefacts

5. Individual files, directories and archives.

6. Deploy the same to the respective environments:

   • Maven deploy to Nexus - Nexus is the option for hosting third-party artefacts, as well as for reusing internal artefacts across development streams.

   • Nexus (sonatype) is a repository manager - It allows you to proxy, collect, and manage your dependencies so that you are not constantly juggling a collection of JARs. It makes it easy to distribute your software. Internally, you configure your build to publish artefacts to Nexus and they then become available to other developers.

Inside ERP Stack

1. Apache Web servers for Load Balancer:

   • Load Balancer - A load balancer is a device that distributes network or application traffic across a cluster of servers. Load balancing improves responsiveness and increases the availability of applications.

   • Apache HTTP Server - is a cross-platform web server. A web server is a software application that receives your request to access a web page. It runs a few security checks on your HTTP request and takes you to the web page.

2. WildFly for Application Servers with instances (with Java as a prerequisite)

   • Application Server - An application server is a software framework that provides both facilities to create web applications and a server environment to run them 2.1 WildFly - is a Java EE 8 certified application server. It provides a list of services as,

3. JDBC connection pool

4. ArtemisMQ - messaging broker

5. Resource adapter

6. EJB container - where you can deploy remote services

7. Undertow - lightweight and performant web server

8. Batch job scheduler to execute tasks and jobs

9. Redis cache for (Tokens, auth, sessions, etc.,)

10. Elastic Search

11. Postgres as DB

Our ERP application architecture follows the 3-tier architecture for web applications.

Accessing The Application Using IP Address And Domain Name

Refer to this section only if you want the application to run using any IP address or domain name.

1. Domains should be registered with hosts

2. Sub-domains must be created and should point to the Load Balancer IP (elastic IP)

   • Examples of sub-domains include - multi-tenant based, environment(DEV/QA/UAT) based and others like issues.jira, etc.,

   • create name-based virtual hosts for the sub-domains, which helps in picking up the right application servers, and schemas likewise.

   tenant.env.domain = name Here, the name refers to hosts, schemas, etc., that help access the application at the right hosts.

3. To access the application using the IP address:

   Have an entry in the table (eg_city) in the database with an IP address of the machine where the application server is running (for ex: domainurl="172.16.2.164") to access the application using the IP address.

   • Access the application using the URL http://172.16.2.164:8080/egi/ where 172.16.2.164 is the IP and 8080 is the port of the machine where the application server is running.

4. To access the application using a domain name:

   • Have an entry in the table (eg_city) in the database with a domain name (for ex: domainurl= "www.egoverpphoenix.org") to access the application using a domain name.

   • Add the entry in the hosts' file of your system with details as 172.16.2.164 www.egoverpphoenix.org (This needs to be done both in the server machine as well as the machines in which the application needs to be accessed since this is not a public domain).

   • Access the application using the URL http://www.egoverpphoenix.org:8080/egi/ where www.egoverpphoenix.org is the domain name and 8080 is the port of the machine where the application server is running.

   • Always start the Wildfly server with the below command to access the application using the IP address or domain name. nohup ./standalone.sh -b 0.0.0.0 &

Deployment

There are two approaches to deployment:

1. Manual Deployment - Copy the EAR files on the deployment folder and start the server.

2. Hot Deployment - using WildFly management console(it always listens at 9990), and using curl upload and publish the EAR.

Release Process

3-Tier Architecture in ERP (refer to the image below).

A typical enterprise application consists of at least three different types of components:

1. Presentation layer – Components that handle HTTP requests and implement either a (REST) API or an HTML‑based web UI. In an application that has a sophisticated user interface, the presentation tier is often a substantial body of code.

2. Business logic layer – Components that are the core of the application and implement the business rules.

3. Data‑access layer – Components that access infrastructure components such as databases and message brokers.

A three-tier architecture is a client-server architecture in which the functional process logic, data access, computer data storage and user interface are developed and maintained as independent modules on separate platforms. Three-tier architecture is a software design pattern and a well-established software architecture.

Overview

This page contains steps that are involved in building and deploying the application. FAQ related to various deployment and development issues are discussed

Setup Using Auto-installer

• Clone the eGov repository (development is done on the develop branch).

1$ mkdir -p ${HOME}/egovgithub && cd egovgithub 2$ git clone -b develop --single-branch <https://github.com/egovernments/egov-smartcity-suite.git>

• First time setup which will install the stacks, build the source code, and deploys the artefact to Wildfly

1$ cd ${HOME}/egovgithub/egov-smartcity-suite && make all

• To install the prerequisites Phoenix stacks

1$ cd ${HOME}/egovgithub/egov-smartcity-suite && make install

• To build the source code base

1$ cd ${HOME}/egovgithub/egov-smartcity-suite && make build

• To deploy the artefact to WILDFLY

1$ cd ${HOME}/egovgithub/egov-smartcity-suite && make deploy

Manual Setup

Pre-requisites

Database Setup

1. Create a database and user in postgres

2. Create a schema called generic

3. Execute ALTER ROLE <your_login_role> SET search_path TO generic,public;

Elastic Search Setup

Elastic search server properties need to be configured in elasticsearch.yml under <ELASTICSEARCH_INSTALL_DIR>/config1## Your local elasticsearch clustername, DO NOT use default clustername 2cluster.name: elasticsearch-<username> 3## This is the default port 4transport.tcp.port: 9300 5

NB: <username> user name of the logged-in system, enter the below command in terminal to find the username.1$ id -un

Building Source

1. Clone the eGov repository (development is done on the develop branch.

1$ mkdir egovgithub 2$ cd egovgithub 3$ git clone <https://github.com/egovernments/egov-smartcity-suite.git> 4$ git checkout develop

1. Change directory to <CLONED_REPO_DIR>/egov/egov-config/src/main/resources/config/ and create a file called egov-erp-<username>.properties and enter the following values based on your environment config.

1##comma separated list of host names 2elasticsearch.hosts=localhost 3elasticsearch.port=9300 4elasticsearch.cluster.name=elasticsearch-<username> 5

If required, you can override any default settings available in /egov/egov-egi/src/main/resources/config/application-config.properties by overriding the value in egov-erp-<username>.properties.

1. Change directory back to <CLONED_REPO_DIR>/egov

2. Run the following commands. This will clean, compile, test, migrate the database and generate ear artefact along with jars and wars appropriately.

1mvn clean package -s settings.xml -Ddb.user=<db_username> -Ddb.password=<db_password> -Ddb.driver=org.postgresql.Driver -Ddb.url=<jdbc_url>

Redis Server Setup

By default eGov suit uses an embedded redis server (work only in Linux & OSx), to make the eGov suit work in Windows OS or if you want to run redis server as a standalone then follow the installation steps below.

1. Installing redis server on Linux

1sudo apt-get install redis-server

2. Once installed, set the below property in egov-erp-override.properties or egov-erp-<username>.properties.

1## true by default 2redis.enable.embedded=false

to control the redis server host and port use the following property values (only required if installed with non-default).1## Replace <your_redis_server_host> with your redis host, localhost by default 2redis.host.name=<your_redis_server_host> 3## Replace <your_redis_server_port> with your redis port, 6379 by default 4redis.host.port=<your_redis_server_port>

Deploying Application

Configuring JBoss Wildfly

2. In case, properties needs to be overridden, edit the below file (This is only required if egov-erp-<username>.properties is not present)

1<JBOSS_HOME>/modules/system/layers/base/ 2 3org 4└── egov 5 └── settings 6 └── main 7 ├── config 8 │ └── egov-erp-override.properties 9 └── module.xml

1. Update settings in standalone.xml under <JBOSS_HOME>/standalone/configuration

• Check Datasource setting is in sync with your database details.

1<connection-url>jdbc:postgresql://localhost:5432/<YOUR_DB_NAME></connection-url> 2<security> 3 <user-name><YOUR_DB_USER_NAME></user-name> 4 <password><YOUR_DB_USER_PASSWORD></password 5</security>

• Check HTTP port configuration is correct in

1<socket-binding name="http" port="${jboss.http.port:8080}"/>

1. Change directory back to <CLONED_REPO_DIR>/egov/dev-utils/deployment/ and run the below command

1$ chmod +x deploy.sh 2$ ./deploy.sh

Alternatively, this can be done manually by following the below steps.

• Copy the generated exploded ear <CLONED_REPO_DIR>/egov/egov-ear/target/egov-ear-<VERSION>.ear in to your JBoss deployment folder <JBOSS_HOME>/standalone/deployments

• Create or touch a file named egov-ear-<VERSION>.ear.dodeploy to make sure JBoss picks it up for auto-deployment

1. Start the wildfly server by executing the below command

1 $ cd <JBOSS_HOME>/bin/ 2 $ nohup ./standalone.sh -b 0.0.0.0 & 3

In Mac OSx, it may also required to specify -Djboss.modules.system.pkgs=org.jboss.byteman

-b 0.0.0.0 only required if the application accessed using an IP address or domain name.

1. Monitor the logs and in case of successful deployment, just hit <http://localhost:<YOUR_HTTP_PORT>/egi> in your favourite browser.

2. Log in using the username as egovernments and password demo

Accessing the application using IP address and domain name

This section is to be referred to only if you want the application to run using any IP address or domain name.

1. To access the application using an IP address:

• Have an entry in eg_city table in the database with an IP address of the machine where the application server is running (for ex: domainurl="172.16.2.164") to access the application using the IP address.

2. To access the application using the domain name:

Always start the wildfly server with the below command to access the application using IP address or domain name.1 nohup ./standalone.sh -b 0.0.0.0 &

Developer Guide

This section gives more details regarding developing and contributing to the eGov suit.

Repository Structure

egov - folder contains all the source code of eGov opensource projects

Check out sources

git clone git@github.com:egovernments/egov-smartcity-suite.git or git clone <https://github.com/egovernments/egov-smartcity-suite.git>

Pre-requisites

• Install your favourite IDE for the Java project. Recommended Eclipse or IntelliJ IDEA

Note: Please check-in [eGov Tools Repository] for any of the above software installables before downloading from the Internet.

1. Eclipse Deployment

• Import the cloned git repo using maven Import Existing Project.

• Install Jboss Tools and configure Wildfly Server.

• Since jasperreport related jar's are not available in maven central, we have to tell eclipse to find jar's in alternative place for that navigate to Windows -> Preference -> Maven -> User Settings -> Browse Global Settings and point settings.xml available under egov-erp/

• Now add your EAR project into the configured Wildfly server.

• Start Wildfly in debug mode, this will enable hot deployment.

2. Intellij Deployment

• Install Intellij

• Open project

• In project settings set JDK to 1.8

• Add a run configuration for JBoss and point the JBOSS home to the wildfly unzipped folder

• Run

3. Database Migration Procedure

• Any new sql files created should be added under directory <CLONED_REPO_DIR>/egov/egov-<javaproject>/src/main/resources/db/migration

• Core product DDL and DML should be added under <CLONED_REPO_DIR>/egov/egov-<javaproject>/src/main/resources/db/migration/main

• Core product sample data DML should be added under <CLONED_REPO_DIR>/egov/egov-<javaproject>/src/main/resources/db/migration/sample

• All SQL scripts should be named in the following format.

• Format V<timestamp-in-YYYYMMDDHHMMSS-format>__<module-name>_<description>.sql

• DB migration will automatically happen when the application server starts, in case required while maven builds to use the above-given maven command.

Migration file name sample

1V20150918161507__egi_initial_data.sql 2

Note: This system is supported

OS:-

• Linux (Recommended)

• Mac

• Windows (If Redis server standalone installed).

Browser:-

• Chrome (Recommended)

• Firefox

• Internet Explorer