How DNS (Domain Name system ) server works

Mule: How to ignore munit test cases

Sometimes just to get a quick success build you might need to disable/ignore/skip some of the munit test cases.

you can do you by double clicking on the munit test cases and by selecting the "Ignore test" from the property view.

From Maven Console:

If you want to all all the Munit Test you can do it using "DskipMunitTests" flat

 $ mvn clean package  -DskipMunitTests



Related Info:
Munit Best practice: https://www.mulesoft.com/ty/webinars/best-practices-testing-mule-applications

Nginx: Tips and Tricks

What is the Configuration File for Nginx and where it can be in UNIX like Systems?

Configuration file is named nginx.conf and placed in the directory;

 /usr/local/nginx/conf, /etc/nginx     or

/usr/local/etc/nginx          depends on distribution.

what are the configuration files available for Nginx ?

       1.      Default configuration directory: /etc/nginx/

2.      Default SSL and vhost config directory: /etc/nginx/conf.d/

3.      Default log file directory: /var/log/nginx/

4.      Default document root directory: /usr/share/nginx/html

5.      Default configuration file: /etc/nginx/nginx.conf

6.      Default server access log file: /var/log/nginx/access.log

7.      Default server access log file: /var/log/nginx/error.log

       How to check nginx syntax or configuration:

         sudo /etc/init.d/nginx configtest

           
        How to Reload Nginx:


         sudo /etc/init.d/nginx reload

Docker: Some Important Commands

Start Docker :

$ sudo systemctl start docker                                                                                             

List All the Available Docker Images :

  $ sudo docker images                              

Download a docker image from docker hub:

 $ sudo docker pull rabbitmq                     

Management Commands:

  config      Manage Docker configs

  container   Manage containers

  image       Manage images

  network     Manage networks

  node        Manage Swarm nodes

  plugin      Manage plugins

  secret      Manage Docker secrets

  service     Manage services

  stack       Manage Docker stacks

  swarm       Manage Swarm

  system      Manage Docker

  trust       Manage trust on Docker images

  volume      Manage volumes

Commands:

  attach      Attach local standard input, output, and error streams to a running container

  build       Build an image from a Dockerfile

  commit      Create a new image from a container's changes

  cp          Copy files/folders between a container and the local filesystem

  create      Create a new container

  deploy      Deploy a new stack or update an existing stack

  diff        Inspect changes to files or directories on a container's filesystem

  events      Get real time events from the server

  exec        Run a command in a running container

  export      Export a container's filesystem as a tar archive

  history     Show the history of an image

  images      List images

  import      Import the contents from a tarball to create a filesystem image

  info        Display system-wide information

  inspect     Return low-level information on Docker objects

  kill        Kill one or more running containers

  load        Load an image from a tar archive or STDIN

  login       Log in to a Docker registry

  logout      Log out from a Docker registry

  logs        Fetch the logs of a container

  pause       Pause all processes within one or more containers

  port        List port mappings or a specific mapping for the container

  ps          List containers

  pull        Pull an image or a repository from a registry

  push        Push an image or a repository to a registry

  rename      Rename a container

  restart     Restart one or more containers

  rm          Remove one or more containers

  rmi         Remove one or more images

  run         Run a command in a new container

  save        Save one or more images to a tar archive (streamed to STDOUT by default)

  search      Search the Docker Hub for images

  start       Start one or more stopped containers

  stats       Display a live stream of container(s) resource usage statistics

  stop        Stop one or more running containers

  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE

  top         Display the running processes of a container

  unpause     Unpause all processes within one or more containers

  update      Update configuration of one or more containers

  version     Show the Docker version information

  wait        Block until one or more containers stop, then print their exit codes

Scrum : Quick Reference

Product Backlog :

So what exactly do you put into a Product Backlog

Feature Requests: Any request from a stakeholder (e.g., “I want admin access.” “I want to be able to sort this list.”) 

Nonfunctional Requirements: Qualities of the system (e.g., Performance, Scalable to 2,000 concurrent users, Legal Terms & Conditions) 

Experiments: Functionality that is released to production to test the marketplace (e.g., New UI, User Survey, Analytics); also, experiments can be “enabling constraints,”

User Stories: Placeholders for conversations; popular in the agile community 

Bugs/Defects: Problems that have arisen from a previous release 

Use Cases: List of actions between an actor and a system (not as common these days) 

Capabilities: Different ways or channels to access existing functionality (e.g., mobile, web, cloud services, public API)As a framework, 

Scrum does not prescribe any real method or template for Product Backlog items. However, the vast majority of Scrum Teams populate their Product Backlogs with user stories.

Some example of "Done" List:

•  Unit tested

•  Code reviewed

•  Matches code style guide

•  No known defects

•  Checked into main dev branch 

• Public API documented

• Acceptance tests pass

• Product Owner approved

• Regression tests pass

• Release notes updated 

• Performance tests pass

• User guide updated

• Support guide updated

• Security tests pass

• Compliance documentation updated

Software Estimation Tools and Technique

Important Concept to Understand:

1. Software Sizing
• In order to perform software estimation, first you needed understand what is software size and how to perform appropriate software sizing
1. Function point
2. Use case point
3. Object Point
4. Mark II function point analysis
5. Software size units
2. Effort Estimation
3. Productivity 

APPROPRIATE SOFTWARE-SIZING TECHNIQUE:

• Try using function points. This technique is by far the most popular and most widely used, but first you need to learn it. Many free, downloadable resources are available on the Internet for self-teaching

• Use task-based estimation. This is simply estimating the effort required for each of the components in the work breakdown structure to arrive at the total effort needed for the project. This technique is explained in subsequent chapters.

When the actual effort varies from the estimated effort by more than chance variation (that is, by more than 10 percent), the following could be the reasons:

• The actual size of the software produced varies from the estimated software size
• While the estimate assumes average skill and average effort, the allocation of manpower could result in predominantly poorly skilled (or super-skilled) manpower for the project execution
• Project execution could be sloppy (or excellent)
• Estimation norms could be wrong

Software Architectural book references

1. Building Evolutionary Architectures: Support Constant Change 1st Edition
by Neal Ford

2. Design It!: From Programmer to Software Architect (The Pragmatic Programmers) 1st Edition
by Michael Keeling

3. Patterns of Enterprise Application Architecture 1st Edition
by Martin Fowler

4. Clean Architecture: A Craftsman's Guide to Software Structure and Design 1st Edition
by Robert C. Martin

5. Microservice Patterns and Best Practices: Explore patterns like CQRS and event sourcing to create scalable, maintainable, and testable microservices Paperback – January 31, 2018
by Vinicius Feitosa Pacheco

6. Microservices Patterns: With examples in Java 1st Edition
by Chris Richardson

7. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems 1st Edition
by Martin Kleppmann

8. Web Scalability for Startup Engineers 1st Edition
by Artur Ejsmont

9. Domain-Driven Design: Tackling Complexity in the Heart of Software Hardcover – Aug 20 2003
by Eric Evans