GIT Branching Model

Idea Extracted from this website as I had the liberty to learn from it and apply it to my personal projects as well as in some of the organizations I work for.

The details are summarized as follows:

Overall picture:

Main branches:

• MASTER 
• DEVELOP

We consider origin/master to be the main branch where the source code of HEAD always reflects a production-ready state

We consider origin/develop to be the main branch where the source code of HEAD always reflects a state with the latest delivered development changes for the next release. Some would call this the “integration branch”. This is where any automatic nightly builds are built from

When the source code in the develop branch reaches a stable point and is ready to be released, all of the changes should be merged back into master somehow and then tagged with a release number.

Other Branches

• Feature branches
• Release branches
• Hotfix branches

Unlike the main branches, these branches always have a limited life time, since they will be removed eventually.

Feature:
May branch off from: develop Must merge back into: develop

Finished features may be merged into the develop branch to definitely add them to the upcoming release.

Release:
May branch off from: develop Must merge back into: develop and master
It is exactly at the start of a release branch that the upcoming release gets assigned a version number—not any earlier.
This new branch may exist there for a while, until the release may be rolled out definitely. During that time, bug fixes may be applied in this branch (rather than on the develop branch).

When the state of the release branch is ready to become a real release, some actions need to be carried out. First, the release branch is merged into master (since every commit on master is a new release by definition, remember). Next, that commit on master must be tagged for easy future reference to this historical version

Finally, the changes made on the release branch need to be merged back into develop, so that future releases also contain these bug fixes.

Hotfix:
May branch off from: master Must merge back into: develop and master

When finished, the bugfix needs to be merged back into master, but also needs to be merged back into develop, in order to safeguard that the bugfix is included in the next release as well. 

React Redux Concepts

Redux is a tool for managing both data-state and UI-state in JavaScript applications.

Redux attempts to make state mutations predictable by imposing certain restrictions on how and when updates can happen.

Core principals:

1. The state of your whole application is stored in an object tree within a single store.
2. The only way to change the state is to emit an action, an object describing what happened.
3. To specify how the state tree is transformed by actions, you write pure reducers. Reducers are just pure functions that take the previous state and an action, and return the next state. 

What React Solves:


Component to Component communication is hard in react, as data flows from top to bottom.

For communication between two components that don't have a parent-child relationship, you can set up your own global event system. ... Flux pattern is one of the possible ways to arrange this.


React solves the above problem by introducing a global store. Components then "dispatch" state changes to the store, not directly to other components. The components that need to be aware of state changes can "subscribe" to the store:

npm install --save redux react-redux  

Wildfly 10.1 Webservice Security with Custom Login Module

source code:   https://github.com/byorn/wildfly-webservice-security

A Sample EAR extracted from the Wildfly Quickstarts can be found from the above source.

It contains a @Webservice and @SecurityDomain, protecting the @Webmethod with defined roles.

In the project's EJB Section, is the Module DelegationLoginModule.

This is a custom Login Module. All the information on how to authentication the user name and password is described in the source comments.


The Standalone.xml in Wildfly10 should have this configuration:


<security-domain name="other" cache-type="default">
                    <authentication>
                        <login-module code="byorns.com.login.module.DelegationLoginModule" flag="required">
                            <module-option name="password-stacking" value="useFirstPass"/>
                        </login-module>
                    
                    </authentication>
                </security-domain>

web.xml should have
<login-config>

   <auth-method>BASIC</auth-method>   <realm-name>RealmUsersRoles</realm-name></login-config>

Test with SOAP UI, Basic Authentication:

For more security related debugs:

Add the logger in Standalone.xml

 <logger category="org.jboss.security">

                <level name="TRACE"/>

</logger>

Starting React Development

The quickest way to get started with react is to follow the official react tutorial.

Firstly you would want to make sure you have Node installed in your machine.

To download Node, go to: https://nodejs.org/en/download/

If you already have node installed, make sure it is updated to its latest version:

> npm install npm@latest -g

Next create the skeleton react app using create-react-app program

> npm install -g create-react-app

> create-react-app my-app

> cd my-app

> npm start  

To work with React Projects, I use ATOM with added plugin Language-Babel package.

To Build React for Production use:

> npm run build

This will create a build folder and the index.html and its contents can be hosted in production.

To run it, you can install the serve program

> npm install -g serve

> serve -s build

Note: 

create-react-app uses Webpack underneath it to  bundle your code and all its dependencies, It also uses also uses Babel to Tranform next generation java script (llike es6) to browser compatible java scripts

REACT Basic Concepts

React is a UI library.

Its focuses on  interactive, stateful & reusable UI components.

A Unique selling point about REACT  is that not only does it perform on the client side, but it can also be rendered in server side, and they can work together inter-operably.

React has the a concept of the Virtual DOM. Based on state changes, only selected subset of the dom elements are updated. (Least amount of dom manipulation is required, with the use of the Virtual DOM)

React uses JSX (Javascript XML syntax transform)  to write HTML Tags in Java Script. This is similar concept of Angular's Templates.

Rendering

var MyComponent = React.createClass({
    render: function(){
        return (
            <h1>Hello, world!</h1>
        );
    }
});

ReactDOM.render(
    <MyComponent/>,
    document.getElementById('myDiv')
);

ReactDOM’s render method above, our first argument is the component we want to render, and the second is the DOM node it should mount to.

State

Every component has a state object and a props object.
State is set using the setState method. Calling setState triggers UI updates.If we want to set an initial state before any interaction occurs we can use the getInitialState method.


In React, application data flows unidirectionally via the state and props objects, as opposed to the two-way binding of libraries like Angular.  This means that, in a multi component heirachy, a common parent component should manage the state and pass it down the chain via props.  

In a hierarchichal component structure, the state of the component should be updated using the setState method to ensure that a UI refresh will occur. The resulting values should be passed down to child components using attributes that are accessible in said children via this.props

Adding Oracle's JDK to Ubuntu 14.04

1) Download JDK, and install it into any directory of your choice, mine was /home/byorn/Programs/java/

2) sudo update-alternatives --install "/usr/bin/java" "java"  "/home/byorn/Programs/java/jdk1.7.0_21/bin/java" 1

3) sudo update-alternatives --config java

and select your option.

To Test type:  java -version