**Understanding Transactions**

A transaction is a set of operations that should either all succeed or all fail. For instance, when transferring money between two bank accounts, its essential that both the withdrawal from one account and the deposit into the other account happen together.
 

**Setting Up Your Project**

Make sure you have Spring Boot and a database set up in your project. You can use **[Spring Initializer](https://start.spring.io/)** to generate a new project with the required dependencies.
 

**Adding JPA Repository**

Create a JPA entity (e.g., User) and a corresponding repository interface (e.g., UserRepository) that extends JpaRepository. This will give you access to basic CRUD operations.
 

```java
@Entity
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 private String username;
 private String email;

 // Getters and setters
}

public interface UserRepository extends JpaRepository<User, Long> {
 // Custom queries can be defined here if needed
}
```

Using **@Transactional**
Lets say you have a service class (e.g., UserService) where you want to perform some business logic involving multiple database operations.

```java
@Component
@Service
public class UserService {

 @Autowired
 private UserRepository userRepository;

 @Transactional
 public void performBusinessLogic(User user) {
 userRepository.save(user);
 // Additional database operations...

 // If an exception occurs here, the entire transaction will be rolled back
 }
}
```

Explaining **@Transactional**
@Transactional is placed on top of the method that should be transactional.
 
If any exception occurs during the method execution, the entire transaction is rolled back (i.e., all changes made within the transaction are undone).
If the method completes successfully, the transaction is committed.
Understanding Transactional Propagation in Spring Boot
In addition to using **@Transactional**, its important to understand transaction propagation when working with Spring Boot and JPA. Transaction propagation defines the behavior of a method that is already running within a transaction context when another method is invoked.
 
 

**Types of Transactional Propagation**
 
1. REQUIRED (Default):
 
If there is an existing transaction, the method will participate in that transaction. If there is no existing transaction, a new transaction will be created.
 
 
2. REQUIRES_NEW:
 
This always starts a new transaction. If there is an existing transaction, it will be suspended until this new transaction completes.
 
 
3. SUPPORTS:
 
If there is an existing transaction, the method will participate in that transaction. If there is no existing transaction, the method will execute non-transactionally.
 
 
4. MANDATORY:
 
Requires an existing transaction. If there is no existing transaction, an exception will be thrown.
 
 
5. NOT_SUPPORTED:
 
Executes non-transactionally. If there is an existing transaction, it will be suspended until this method completes.
 
 
6. NEVER:
 
Requires that no transaction exists. If an existing transaction is found, an exception will be thrown.
 
 
7. NESTED:
 
Creates a nested transaction. If there is no existing transaction, it behaves like REQUIRED.
Examples of Transactional Propagation
Lets consider an example where we have two methods, methodA() and methodB(), both annotated with @Transactional:
 
 
Testing the Transaction
 
You can write a test to see @Transactional in action:


```java
@SpringBootTest
class UserServiceTest {

 @Autowired
 private UserService userService;

 @Test
 void testBusinessLogic() {
 User user = new User();
 user.setUsername("john_doe");
 user.setEmail("john@example.com");

 userService.performBusinessLogic(user);

 // Verify that the user was saved to the database
 Optional<User> savedUser = userRepository.findById(user.getId());
 assertTrue(savedUser.isPresent());
 }
}
```
In this example:
 
 

methodA() starts a new transaction (if none exists) and saves a new user (Alice). It then calls methodB().
 
methodB() always starts a new transaction and saves a new user (Bob). If methodB() is called within an existing transaction, that transaction is suspended until methodB() completes.
 
 
Conclusion
 
Understanding transaction propagation is crucial for building robust applications with Spring Boot and JPA. By choosing the right propagation type, you can ensure that your transactions behave as expected and maintain data integrity.

Remember to carefully design your transactions based on the requirements of your application to achieve the desired behavior.

 
 
Happy coding!

Using @Transactional with Spring Boot and JPA

**Simple Past Tense in English Grammar** 

In English grammar, the simple past tense is one of the essential tenses used to describe actions, events, or situations that occurred and were completed in the past.
Understanding how to form and use the simple past tense is crucial for effective communication in English. In this guide, we'll explore the formation, usage, and examples of the simple past tense.
 

**Formation of Simple Past Tense:** 
The simple past tense is primarily formed by adding "-ed" to the base form of regular verbs. However, irregular verbs have unique past tense forms that must be memorized. Here are the basic rules for forming the simple past tense:

**Regular Verbs:** 

**Base Form: Work** 
Simple Past Tense: Worked 
Example: She worked late yesterday. 
**Irregular Verbs:** 

**Base Form: Go**
Simple Past Tense: Went
Example: They went to the beach last weekend.
Usage of Simple Past Tense:
The simple past tense is used to describe actions, events, or situations that occurred at a specific time in the past and are now completed. It is often used to:

Describe completed actions in the past:

She finished her homework before dinner.
He visited his grandparents last summer.
Describe a series of completed actions:

I woke up, had breakfast, and went to work.
They bought groceries, cooked dinner, and watched a movie.
Narrate past events in stories or recounts:

Once upon a time, there was a princess who lived in a castle.
Last year, we traveled to Europe and visited many countries.
Express past habits or states:

When I was a child, I played soccer every day.
She always wore a hat when it was sunny.
Negative and Interrogative Forms:
To form negative sentences and questions in the simple past tense, the auxiliary verb "did" is used with the base form of the main verb. Here are the forms:
 


**Negative Form:** 

She did not finish her work on time.
They did not attend the meeting yesterday.
Interrogative Form:

Did you see the movie last night?
Did they visit the museum on Sunday?
Conclusion:
Mastering the simple past tense is essential for effective communication in English.
By understanding how to form and use the simple past tense, you can accurately describe past events, actions, and states. Practice using the simple past tense in your everyday conversations and writing to improve your English language skills.

Simple Past Tense English Lesson

It needs two files. One of them is curator **config.yml** whose names is **curator.yml** and second file whose name is **test-delete-indices.yml**.
 

**YAML-based Curator Configuration**

Elasticsearch host which is in environment, must be written like above 127.0.0.1 if it is in local.
 

**curator.yml**

```yml
client:
 hosts:
 - 127.0.0.1
 port: 9200
 url_prefix:
 use_ssl: False
 certificate:
 client_cert:
 client_key:
 ssl_no_validate: False
 http_auth:
 timeout: 30
 master_only: False

logging:
 loglevel: DEBUG
 logfile:
 logformat: default
 blacklist: ['elasticsearch', 'urllib3']
```

 

**test-delete-indices.yml**

```yml
actions:
1:
 action: delete_indicex
 description: >-
 Delete access indices
 options:
 ignore_empty_list: True
 timeout_override:
 continue_if_exception: False
 disable_action: False
 filters:
 - filtertype: pattern
 kind: prefix
 value: test-first-incides_
 exclude:
 - filtertype: age
 source: name
 direction: older
 timestring: '%Y%m%d'
 unit: days
 unit_count: 3
 exclude:
```

Once the two YAML files are configured, you can initiate a dry run of curator execution with following command.

```sh
curator /path/test-delete-indices.yml --config /path/curator.yml --dry-run
```

The **--dry-run** mode will not actualy delete the index. It can be used to verify the output of the action.

 

Once the dry run verification is completed, you can schedule the actual run in **cron**, using **crontab -e** as shown below.

```sh
*/5 * * * * sh /usr/local/eops/eops_check.sh > /dev/null 2>&1 &
*/1 * * * * curator /path/test-delete-indices.yml --config /path/curator.yml >> /path/log.log
```

**Note: /path/.. must be written correctly as located**. 
**Note: Result of these commands are written log.log file**.

It will be all indices after before **3 days**.

**test-first-incides_20210526 
test-first-incides_20210525 
test-first-incides_20210524 
test-first-incides_20210523 **_will be deleted_** 
test-first-incides_20210522 **_will be deleted_** 
... 
...**

Deleting Elasticsearch Indices By Timestamp

Elasticsearch provides near real-time search and analytics for all types of data. Whether you have structured or unstructured text, numerical data, or geospatial data,
Elasticsearch can efficiently store and index it in a way that supports fast searches. You can go far beyond simple data retrieval and aggregate information to discover trends and patterns in your data. And as your data and query volume grows, the distributed nature of Elasticsearch enables your deployment to grow seamlessly right along with it.

While not every problem is a search problem, Elasticsearch offers speed and flexibility to handle data in a wide variety of use cases:

Add a search box to an app or website
Store and analyze logs, metrics, and security event data
Use machine learning to automatically model the behavior of your data in real time
Automate business workflows using Elasticsearch as a storage engine
Manage, integrate, and analyze spatial information using Elasticsearch as a geographic information system (GIS)
Store and process genetic data using Elasticsearch as a bioinformatics research tool
We’re continually amazed by the novel ways people use search. But whether your use case is similar to one of these, or you’re using Elasticsearch to tackle a new problem, the way you work with your data, documents, and indices in Elasticsearch is the same.

You can follow on [docs of elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/elasticsearch-intro.html#elasticsearch-intro).

**Pulling the image** 
Obtaining Elasticsearch for Docker is as simple as issuing a docker pull command against the Elastic Docker registry.

```sh
docker pull docker.elastic.co/elasticsearch/elasticsearch:7.13.0
```

**1.Starting a single node cluster with Dockeredit** 
To start a single-node Elasticsearch cluster for development or testing, specify single-node discovery to bypass the bootstrap checks:

```sh
docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:7.13.0
```

**2.Starting a multi-node cluster with Docker Composeedit**
To get a three-node Elasticsearch cluster up and running in Docker, you can use Docker Compose:

Create a **docker-compose.yml** file:

```yml
version: '2.2'
services:
 es01:
 image: docker.elastic.co/elasticsearch/elasticsearch:7.13.0
 container_name: es01
 environment:
 - node.name=es01
 - cluster.name=es-docker-cluster
 - discovery.seed_hosts=es02,es03
 - cluster.initial_master_nodes=es01,es02,es03
 - bootstrap.memory_lock=true
 - 'ES_JAVA_OPTS=-Xms512m -Xmx512m'
 ulimits:
 memlock:
 soft: -1
 hard: -1
 volumes:
 - data01:/usr/share/elasticsearch/data
 ports:
 - 9200:9200
 networks:
 - elastic
 es02:
 image: docker.elastic.co/elasticsearch/elasticsearch:7.13.0
 container_name: es02
 environment:
 - node.name=es02
 - cluster.name=es-docker-cluster
 - discovery.seed_hosts=es01,es03
 - cluster.initial_master_nodes=es01,es02,es03
 - bootstrap.memory_lock=true
 - 'ES_JAVA_OPTS=-Xms512m -Xmx512m'
 ulimits:
 memlock:
 soft: -1
 hard: -1
 volumes:
 - data02:/usr/share/elasticsearch/data
 networks:
 - elastic
 es03:
 image: docker.elastic.co/elasticsearch/elasticsearch:7.13.0
 container_name: es03
 environment:
 - node.name=es03
 - cluster.name=es-docker-cluster
 - discovery.seed_hosts=es01,es02
 - cluster.initial_master_nodes=es01,es02,es03
 - bootstrap.memory_lock=true
 - 'ES_JAVA_OPTS=-Xms512m -Xmx512m'
 ulimits:
 memlock:
 soft: -1
 hard: -1
 volumes:
 - data03:/usr/share/elasticsearch/data
 networks:
 - elastic

volumes:
 data01:
 driver: local
 data02:
 driver: local
 data03:
 driver: local

networks:
 elastic:
 driver: bridge
```

After you handled starting elasticsearch duty, you can check below script in **postman** or **insomnia**.

```sh
GET localhost:9200/_cat/nodes
```

```sh
ip heap.percent ram.percent cpu load_1m load_5m load_15m node.role master name
172.17.0.2 5 77 1 0.03 0.19 0.18 cdfhilmrstw * a46bf13fa976
```

Running the Elasticsearch on Docker

First of all we need to configure and add related two dependency in order to use powermock.

```xml
<dependency>
 <groupId>org.powermock</groupId>
 <artifactId>powermock-module-junit4</artifactId>
 <version>1.6.4</version>
 <scope>test</scope>
</dependency>
<dependency>
 <groupId>org.powermock</groupId>
 <artifactId>powermock-api-mockito</artifactId>
 <version>1.6.4</version>
 <scope>test</scope>
</dependency>
```

Lets assume spring bean like this.

```java
@Component
public class MyBeanClass{
 public SendingMessage startProcessMyBeanClass(){
 final long id = IdGenerator.generateNewId();
 return new SendingMessage(id, "startProcessMyBeanClass started, and my class
 bean was generated")
 }
}
```

And if we want to test **startProcessMyBeanClass** method, in this test we assume that it's important
for us to mock static call to IdGenerator.generateNewId(). However in order to run the test as spring
integration test. we need to use **SpringJunit4ClassRunner** which prevents us from using the
**PowerMockRunner**.

```java
@RunWith(SpringJunit4ClassRunner.class)
@ContextConfiguration("classpath:/example-context.xml)
@PrepareForTest(IdGenerator.class) //the class where static method exist
public class MyBeanClassTest{
 @Rule
 public PowerMockRule rule = new PowerMockRule();

 @Autowired
 private MyBeanClass classBean;

 @Test
 public void mockStaticMethod() throws Exception{
 // Given
 final long expectedId = 2L;
 mockStatic(IdGenerator.class);
 when(IdGenerator.generateNewId()).thenReturn(expectedId);

 // When
 final SendingMessage message = classBean.startProcessMyBeanClass();

 // thenReturn
 assertEquals(expectedId, message.getId());
 assertEquals("startProcessMyBeanClass started, and my class
 bean was generated, message.content());
 }
}
```

In main aim to use PowerMock is that the static methods can be tested in unit test.
There is a sample which points the one controller in spring.

```java
@WebAppConfiguration
@EnableWebMvc
@SpringJUnitConfig(classes=MainController.class)
@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(SpringJunit4ClassRunner.class)
@PowerMockIgnore("javax.management.*)
//to specify that all classes under the specified package be loaded by the system class loader
@PrepareForTest({TestService.class,TestRandomService.class ...})
//points the classes having the static methods
public class MyBeanClassTest{
 @MockBean
 public TestService testService;

 private static final String userName = "burak kilinc";

 //it can be used for static methods as generic
 private void mockGetUtilService(){
 //assume account service
 GenericAccountService accountService = new GenericAccountService();
 //assume user service
 GenericUserService userService = new GenericUserService();
 PowerMockito.mockStatic(TestService.class);
 PowerMockito.mockStatic(TestRandomService.class);
 //when
 PowerMockito.when(TestService.get(Mockiton.anyString())).thenReturn(accountService);
 }
}
```

Using @Transactional with Spring Boot and JPA

Date : 2024-02-19

Deleting Elasticsearch Indices By Timestamp

Date : 2021-05-26

Running the Elasticsearch on Docker

Date : 2021-05-26

Using PowerMock in Spring JUnit Test

Date : 2021-04-25