Skip to content

Latest commit

 

History

History
136 lines (96 loc) · 4.61 KB

README.md

File metadata and controls

136 lines (96 loc) · 4.61 KB
Raw

env-monitor

Build Status

Generic web-based monitoring app for distributed multi-process systems

#Project participants:

  • Yury Yakovlev (env-tools and yyakovlev committers)

Java developer, interested in learning JS, Angular JS, and improving experience with persistence layer technologies for Java.

  • Michal Skuza

Java and AngularJS developer, Luxoft Poland

  • Evgeniy Semenov

Java developer, Luxoft Poland

  • Sergey Moldachev (InnerFlameFact)

Student of LETI University

  • Anastasiya Plotnikova (anastasiya14)

Student of LETI University

  • Maksim Fyodorov (jesa29)

Student of LETI University

  • Ilya Sungurov (bombinmybag)

Javascript developer, interested in learning Java 8, Hibernate, and getting practical experience with Typescript

#How to run: Build web UI:

  • Install npm (is part of node js)
  • If you're behind proxy, set up proxy parameters:
set HTTP_PROXY=http://DOMAIN%5Cusername:[email protected]:PORT
  • Install global gulp (windows only)
npm i [email protected] -g
  • Go to UI module
cd env-monitor/env-monitor/env-monitor-ui/src/main/resources/static/
  • Download npm dependencies: tool dependencies and javascript library dependencies
npm install

Please note: bower is no more used

  • Build project (required if js sources changed or index-template.html changed)
gulp dist
  • If you're doing UI development, start tracking changes in js/css files (so that scripts.js and styles.css are re-generated automatically)
gulp watch

To run the prototype standalone (from command line, using java):

  • Build with maven 3
  • Take jar from env-monitor-ui/target
  • Run with java -jar <jarfile>
  • In command line, use -Dserver.port=<other_port> if you don't like default 8080

To run the prototype standalone (from command line, using maven):

  • Build with maven 3
  • cd env-monitor-ui
  • Run with mvn spring-boot:run

To run the prototype from your IDE

  • Import root maven pom.xml into your project
  • Find class "Application" and method "main", run it from IDE
  • In your run configuration (Java startup settings) use -Dserver.port=<other_port> if you don't like default 8080
  • If you're doing UI development, make sure your current directory is where 'env-monitor-ui' folder is located. This will allow for instant web content re-loading when you refresh Browser page (don't forget 'gulp watch' also).

Final step:

#How to debug: To debug the prototype remotely as a standalone app:

  • cd env-monitor-ui
  • mvn spring-boot:run -Drun.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"
  • Launch remote debugging session in your IDE

To debug from your IDE

  • Run Application::main in debug mode

Caveats

*If SSH is blocked at your PC or there are other SSH connection issues, modify configuration:

  • set applications.provider=org.envtools.monitor.provider.applications.mock.MockApplicationsModuleProvider in application.properties
  • set load-at-startup to false in shell.xShellz.com.xml

#Developers guide

Client/server interaction is built on asynchronous message exchange over Websockets (STOMP protocol). Message format is JSON. The application is built from modules: 1 Core Module and several pluggable modules

  • Core module which is tightly coupled with Spring controllers and always lives together with them
  • M_APPLICATIONS module
  • M_QUERY_LIBRARY module
  • More modules will be added during development

Modules are currently Spring beans which communicate through Spring Integration channels in the same Spring integration context. However they could communicate through a lightweight messaging broker and live in standalone processes (if this is ever implemented)

UI requests are routed to Core module which in turn:

  • either provides response immediately (because has all necessary data)
  • or delegates processing to the responsible module

Currently, the following types of interactions/flows are supported:

  1. Pluggable module sends some data model to Core module (which in turn caches it in memory). This happens on module startup, and also later when it's decided that data has been updated and the update should be sent. Full data is re-sent to be cached. When Core module receives the updated model, it broadcasts the updates for interested client subscribers.

When used: -Applications data is sent by M_APPLICATIONS module :

ApplicationsModule::onModelUpdate()

-Query tree is sent by M_QUERY_LIBRARY module

QueryLibraryModule: treeUpdateTriggerService.triggerUpdate();

  1. // TO BE DONE