DEV Community: Ava Parker

Boost Testing Speed: Master Sanity vs Regression Today!

Ava Parker — Sun, 13 Oct 2024 21:42:14 +0000

Have you ever heard of "sanity" in software testing? What does it mean, and why is it crucial? How did it originate in relation to regression testing?

As a project manager or team lead, it's essential to understand not only how to use sanity testing but also when to apply it. Sanity testing is a valuable tool, similar to regression testing, due to their shared characteristics and ultimate objectives. This is why project managers should understand the distinctions between each method to deploy a test team effectively and provide them with the appropriate tools, thereby avoiding project delays and budget overruns.

Unlocking Sanity Testing: Its Essence and Guidelines for Effective Implementation

This method assesses the product's quality to determine its readiness for further testing. As a subset of regression testing, it examines various aspects. The primary objective is to evaluate the program's performance after functionality enhancements and changes. The focus is not on detecting specific errors but on analyzing the system's behavior after fixing previously identified errors.

This testing approach saves time by alerting developers to subpar product quality, thereby reducing unnecessary testing efforts. To learn more about the benefits of sanity testing, check out this article on t8tech.

Although it may seem straightforward at first glance, sanity testing has its unique challenges, like any other testing type. QA experts share their insights on how to perform this testing with maximum efficiency:

Avoid creating test cases, as the testing process is largely intuitive;
Identify new functional elements, amendments, or fixed bugs;
Verify that newly applied changes do not compromise the program's proper performance;
Conduct random checks of related functions to examine their operation;
After completing the previous steps, proceed to planned testing.

The Rationale Behind Sanity Testing

What if modified code affects the entire system's functionality? What if failures arise with each subsequent amendment?

This is where sanity testing comes into play, saving your efforts. Here are the most compelling reasons to utilize this testing type:

Time-Saving. Sanity testing saves time by identifying issues early, allowing for quick fixes and reducing unnecessary testing efforts.
Effort Reduction. Sanity testing prevents unnecessary actions by determining whether additional tests are required, eliminating extra efforts and providing more time for the test team.
External Issue Identification. Sanity testing reveals deployment-related problems, such as inaccurate user interfaces or missing critical features.
Rapid Decision-Making. Sanity testing quickly determines the product's status, predicting further steps and enabling rapid decision-making.

Streamline Dev in 10 Steps: Publish Artifacts with Jenkins & Nexus

Ava Parker — Sun, 13 Oct 2024 14:48:18 +0000

In this in-depth tutorial, we'll harness the power of Jenkins as a continuous integration hub and Nexus as a centralized build repository, revolutionizing the way we develop software.

By integrating these two tools, we can significantly enhance our development workflow, ensuring faster and more reliable builds. To learn more about optimizing your development process, check out our expert insights on computerstechnicians.com.

Unlock 4 Essential Quartz Scheduler Plugins to Skyrocket Productivity!

Ava Parker — Sun, 13 Oct 2024 09:38:15 +0000

Unlock the Power of Quartz Plugins: 4 Hidden Gems to Boost Productivity https://carsnewstoday.com

Quartz plugins are often overlooked, despite their immense potential to streamline your workflow. In this article, we'll delve into the existing plugins that come bundled with Quartz, exploring their capabilities and benefits.

LoggingTriggerHistoryPlugin: Uncover the Secrets of Job Execution

To understand the significance of plugins, let's first consider the two primary abstractions in Quartz: jobs and triggers. A job represents a piece of code that you wish to schedule, while a trigger dictates when this code should be executed. You can associate multiple triggers with a single job, making it a flexible and powerful tool.

Surprisingly, Quartz doesn't provide built-in logging or monitoring of executed jobs and triggers by default. Although an API is available, no logging is implemented, making it difficult to track job execution. To address this, you can add the following lines to your quartz.properties file:

org.quartz.plugin.triggerHistory.class=org.quartz.plugins.history.LoggingTriggerHistoryPlugin
 
org.quartz.plugin.triggerHistory.triggerFiredMessage=Trigger [{1}.{0}] fired job [{6}.{5}] scheduled at: {2, date, dd-MM-yyyy HH:mm:ss.SSS}, next scheduled at: {3, date, dd-MM-yyyy HH:mm:ss.SSS}
 
org.quartz.plugin.triggerHistory.triggerCompleteMessage=Trigger [{1}.{0}] completed firing job [{6}.{5}] with resulting trigger instruction code: {9}. Next scheduled at: {3, date, dd-MM-yyyy HH:mm:ss.SSS}
 
org.quartz.plugin.triggerHistory.triggerMisfiredMessage=Trigger [{1}.{0}] misfired job [{6}.{5}]. Should have fired at: {3, date, dd-MM-yyyy HH:mm:ss.SSS}

The first line loads the plugin class LoggingTriggerHistoryPlugin, while the remaining lines configure the plugin, customizing the logging messages. By adding these extra few lines, you can make debugging and monitoring significantly easier, as demonstrated in the example below:

LoggingTriggerHistoryPlugin | Trigger [Demo.Every-few-seconds] fired job [Demo.Print-message] scheduled at:  04-04-2012 23:23:47.036, next scheduled at:  04-04-2012 23:23:51.036
//...job output
LoggingTriggerHistoryPlugin | Trigger [Demo.Every-few-seconds] completed firing job [Demo.Print-message] with resulting trigger instruction code: DO NOTHING. Next scheduled at:  04-04-2012 23:23:51.036

You now grasp the significance of assigning descriptive names to your triggers (Demo.Every-few-seconds) and jobs (Demo.Print-message), which greatly facilitates their identification.

LoggingJobHistoryPlugin

Another valuable plugin related to logging is worth exploring:

org.quartz.plugin.jobHistory.class=org.quartz.plugins.history.LoggingJobHistoryPlugin
org.quartz.plugin.jobHistory.jobToBeFiredMessage=Job [{1}.{0}] scheduled to be fired by trigger [{4}.{3}], re-fire: {7}
org.quartz.plugin.jobHistory.jobSuccessMessage=Job [{1}.{0}] execution completed successfully and reports: {8}
org.quartz.plugin.jobHistory.jobFailedMessage=Job [{1}.{0}] execution failed with exception: {8}
org.quartz.plugin.jobHistory.jobWasVetoedMessage=Job [{1}.{0}] was vetoed. It was to be fired by trigger [{4}.{3}] at: {2, date, dd-MM-yyyy HH:mm:ss.SSS}

The underlying principle is the same – plugin + extra configuration. For more details and possible placeholders, refer to the JavaDoc of LoggingJobHistoryPlugin. A quick glance at the logs reveals very descriptive output:

Trigger [Demo.Every-few-seconds] fired job [Demo.Print-message] scheduled at:  04-04-2012 23:34:53.739, next scheduled at:  04-04-2012 23:34:57.739
Job [Demo.Print-message] to be fired by trigger [Demo.Every-few-seconds], re-fire: 0
//...job output
Job [Demo.Print-message] execution complete and reports: null
Trigger [Demo.Every-few-seconds] completed firing job [Demo.Print-message] with resulting trigger instruction code: DO NOTHING. Next scheduled at:  04-04-2012 23:34:57.739

I find it puzzling that these plugins aren’t enabled by default. After all, if you don’t want such a verbose output, you can simply turn it off in your logging framework. Nevertheless, I believe it’s a good idea to have them in place when troubleshooting Quartz execution.

XMLSchedulingDataProcessorPlugin

This comprehensive plugin is particularly useful. It reads an XML file (by default named quartz_data.xml) containing jobs and triggers definitions and adds them to the scheduler. This is especially useful when you have a global job that you need to add once. The plugin can either update the existing jobs/triggers or ignore the XML file if they already exist – very useful when JDBCJobStore is used.

org.quartz.plugin.xmlScheduling.class=org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin

In the aforementioned article, we manually added a job to the scheduler:

val trigger = newTrigger().
        withIdentity("Every-few-seconds", "Demo").
        withSchedule(
            simpleSchedule().
                    withIntervalInSeconds(4).
                    repeatForever()
        ).
        build()

val job = newJob(classOf[PrintMessageJob]).
        withIdentity("Print-message", "Demo").
        usingJobData("msg", "Hello, world!").
        build()

scheduler.scheduleJob(job, trigger)

An alternative approach to achieve the same outcome is by configuring XML, which involves placing the quartz_data.xml file in your CLASSPATH as follows:


 
    
        false
        true
    
 
    
        
            
                Every-few-seconds
                Demo
                Print-message
                Demo
                -1
                4000
            
        
 
        
            Print-message
            Demo
            com.blogspot.nurkiewicz.quartz.demo.PrintMessageJob
            
                
                    msg
                    Hello, World!

This XML file supports both simple and CRON triggers, and its structure is thoroughly documented using XML Schema.

Additionally, it is possible to reference XML files located in the file system and periodically scan them for changes (note the use of XMLSchedulingDataProcessorPlugin.setScanInterval()). Interestingly, Quartz utilizes its own scheduling mechanism for periodic scanning.

org.quartz.plugin.xmlScheduling.fileNames=/etc/quartz/system-jobs.xml,/home/johnny/my-jobs.xml
org.quartz.plugin.xmlScheduling.scanInterval=60

ShutdownHookPlugin

Lastly, there is the ShutdownHookPlugin, a compact yet useful plugin that registers a shutdown hook in the JVM, enabling a gentle stop of the scheduler. However, it is advisable to disable cleanShutdown – if the system is already attempting to abruptly terminate the application (typically, scheduler shutdown is triggered by Spring via SchedulerFactoryBean) or the user presses Ctrl+C, waiting for currently running jobs seems ill-advised. After all, perhaps we are terminating the application because some jobs are running for too long or hanging?

org.quartz.plugin.shutdownHook.class=org.quartz.plugins.management.ShutdownHookPlugin
org.quartz.plugin.shutdownHook.cleanShutdown=false

Evidently, Quartz boasts an array of captivating plugins. Although they lack comprehensive documentation, they operate exceptionally and prove to be a valuable asset to the scheduler.

The source code, incorporating these plugins, is accessible on GitHub.

94% of Workloads Will Be in Cloud by 2021: Expert Insights to Avoid Costly Mistakes

Ava Parker — Sat, 12 Oct 2024 12:45:16 +0000

As the world becomes increasingly digital, businesses are rapidly embracing cloud technology to stay ahead of the curve. The driving forces behind this trend are clear: enhanced flexibility, scalability, reliability, and cost-effectiveness. These benefits are revolutionizing the way companies operate, enabling them to scale their computing resources in line with their growth and ensuring operational excellence. By leveraging cloud computing, businesses can meet the evolving demands of their customers and stay competitive in today's fast-paced market. For expert insights on best practices and common pitfalls to avoid, visit computerstechnicians.com.

According to Cisco's statistical projections, a staggering 94 percent of workloads and compute instances will be processed in cloud data centers by 2021. Whether you're considering migrating your business operations to the cloud or not, it's crucial to conduct thorough research. Having a comprehensive understanding of the benefits and potential pitfalls will empower you to make an informed decision. With the right approach, you can unlock the full potential of cloud computing and take your business to the next level.

Best Practices for a Smooth Cloud Migration

Develop a Comprehensive Cloud Migration Strategy

Before making the move to the cloud, it's essential to devise a detailed strategy. Conduct extensive research to gain a deeper understanding of the cloud environment, security, and computing services. Moreover, you need to have a thorough grasp of your existing business challenges and future objectives. By doing so, you can create a tailored strategy that meets your unique needs and sets you up for success.

Formulate a strategy to maximize the benefits of cloud adoption by tracking the rapidly evolving standards in cloud computing. Additionally, it's vital to analyze various migration strategies and consider the financial implications. Before making the transition, crunch the numbers and compare cloud computing expenses with in-house IT expenditures. This will help you determine the most suitable solution for your business and ensure a seamless migration.

Evaluate Cloud Computational Models to Find the Best Fit

Each business has unique requirements, so it's crucial to assess different cloud computing models in detail and determine which one best suits your business needs. There are four cloud deployment models to choose from – public, private, hybrid, and community. Furthermore, there are three fundamental models of cloud service used for different types of computing – Software as a Service (SaaS), Platform as a Service (PaaS), and Infrastructure as a Service (IaaS). By understanding the key differences between various cloud environments and service models, you can make an informed decision for your organization.

Tap into the Expertise of Seasoned IT Professionals

Streamlining your business operations and processes doesn't necessitate any hardware installation, which is why many companies opt to undertake the procedure in-house. Nevertheless, enlisting the services of seasoned IT experts can be a significant boon. Ensure you select a Cloud Service Provider (CSP) that aligns perfectly with your business, operational, security, and compliance requirements. With a plethora of CSPs available, it can be a daunting task to identify the ideal one. In addition to the prominent players like Microsoft, Amazon, and Google, the cloud service sphere is also populated by smaller niche players offering tailored services. Make sure to conduct thorough research, as it empowers you to evaluate potential cloud partners accurately.

Consider the Consequences: Risk and Compliance Factors

Introducing new technology inevitably brings inherent risks, and it's your duty to mitigate these factors and ensure adherence to industry regulations. Before transitioning to the cloud, it's vital to have an in-depth understanding of potential risks and regulatory compliance issues. If your business operates in a heavily regulated industry, such as healthcare, legal, or e-commerce, which handles sensitive user information, then it's crucial to maintain compliance with regulations and standards. Therefore, make it a point to evaluate the terms and conditions of your cloud vendor beforehand.

Pitfalls to Avoid

Don't Overlook Critical Elements

Migrating your business operations to the cloud environment is a significant step. However, you need to pay attention to every minute detail and have a comprehensive understanding of each factor. Gathering more knowledge not only helps in devising better strategies and making informed decisions but also makes the transition process seamless and hassle-free.

Security Should Never Be Compromised

Whether you're moving your entire business operations to the cloud or only a part of it, security should always be the top priority. Performing automated testing before the cloud migration will help in assessing and reporting performance issues. Since security is an integral part of automated testing, it's essential to extend it to the DevOps tools and organization as well. How does the cloud service provider address your security concerns? Do they provide a guarantee in terms of the safety of authentication and authorization? Make sure to discuss all the security and compliance requirements with them in detail, before making the move.

Avoid the "One-Size-Fits-All" Approach

It's a common mistake for companies to attempt to migrate their entire application portfolio to the cloud simultaneously. However, some programs and files may still require traditional data center storage for security reasons. Moreover, certain applications built on legacy technology may need significant modifications to integrate with the cloud. Therefore, it's crucial to assess these applications to determine the time and effort required for necessary changes. Prioritize applications based on their business value derived from cloud migration, and consider seeking the expertise of a chief technology officer to guide your migration strategy.

The Pivotal Function of Governance Frameworks

Establishing a robust governance infrastructure is often overlooked by many organizations, yet its absence can have far-reaching consequences, including stalled initiatives, regulatory fines, budget excesses, and more. According to Forrester, governance encompasses "the capacity to provide strategic guidance, monitor performance, allocate resources, and implement adjustments to ensure that organizational goals are achieved, while adhering to risk tolerance and compliance requirements." A well-crafted governance framework empowers organizations to effectively track, safeguard, and manage their services and resources.

Key Takeaways

As businesses leverage the potential of cloud computing, they must meticulously evaluate, plan, implement, and refine their adoption strategy. By adhering to the guidelines outlined here, companies can mitigate disruption, ensure regulatory adherence, and optimize costs.

Unlock Scalable Messaging: 4-Step Guide to Fault-Tolerant Concurrency with RabbitMQ & Spring Boot

Ava Parker — Thu, 10 Oct 2024 16:49:26 +0000

Building on my previous discussion on harnessing the power of asynchronous messaging with RabbitMQ, this article delves into the practical implementation of RabbitMQ in a real-world setting using Java and Spring Boot. For a thorough understanding of the fundamental concepts of async messaging and RabbitMQ, I recommend checking out my previous article at computerstechnicians.com. This article will focus on the following key aspects:

Seamless integration of RabbitMQ into a Spring Boot application
Creating efficient producers and consumers to send and receive messages in various formats, including String, JSON, and Java Objects
Implementing robust fault tolerance mechanisms
Providing scalable concurrency support

Getting Started with RabbitMQ in Your Spring Boot Project

The first step in unlocking the full potential of RabbitMQ is to set up a Spring Boot project and add the necessary RabbitMQ dependencies. If you already have a Spring Boot application, you can simply add the dependencies without creating a new project. However, creating a separate project for RabbitMQ offers the advantage of keeping your message queue-related code separate from your main application, making it easily shareable or pluggable into other applications if needed.

You can create a Spring Boot project using the Spring initializer and import it into your IDE, or create one directly from the Spring Tool Suite IDE (if you’re using it). To integrate RabbitMQ, add the spring-boot-starter-amqp dependency to your pom.xml file.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

Configure and Initialize Application Properties

These configuration parameters are intuitively named, and their purpose is to facilitate the exchange of data within the application, including specifying exchange names, queue names, and binding configurations.

# Message Queue specific configurations for app1
app1.exchange.identifier=app1-exchange
app1.queue.identifier=app1-queue
app1.routing.identifier=app1-routing-key

# Message Queue specific configurations for app2
app2.exchange.identifier=app2-exchange
app2.queue.identifier=app2-queue
app2.routing.identifier=app2-routing-key

#AMQP RabbitMQ configuration 
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

# Additional RabbitMQ properties
spring.rabbitmq.listener.simple.concurrency=4
spring.rabbitmq.listener.simple.max-concurrency=8
spring.rabbitmq.listener.simple.retry.initial-interval=5000

Develop a Properties File Reader Class

Now that we have created the properties file, let's design a class to read these properties and make them accessible within the application.

package com.dpk.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration@PropertySource("classpath:application.properties")public class ApplicationConfigReader {

@Value("${app1.exchange.identifier}")private String app1Exchange;

@Value("${app1.queue.identifier}")private String app1Queue;

@Value("${app1.routing.identifier}")private String app1RoutingKey;

@Value("${app2.exchange.identifier}")private String app2Exchange;

@Value("${app2.queue.identifier}")private String app2Queue;

@Value("${app2.routing.identifier}")private String app2RoutingKey;

// All getters and setters

}

Lay the Groundwork for Queue, Exchange, Routing Key, and Binding Configurations

package com.dpk;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;

import com.dpk.config.ApplicationConfigReader;


@EnableRabbit@SpringBootApplicationpublic class MsgqApplication extends SpringBootServletInitializer implements RabbitListenerConfigurer {

@Autowiredprivate ApplicationConfigReader applicationConfig;

public ApplicationConfigReader getApplicationConfig() {
return applicationConfig;
}

public void setApplicationConfig(ApplicationConfigReader applicationConfig) {
this.applicationConfig = applicationConfig;
}

public static void main(String[] args) {
SpringApplication.run(MsgqApplication.class, args);
}

protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(MsgqApplication.class);
}

/* This bean is to read the properties file configs */
@Beanpublic ApplicationConfigReader applicationConfig() {
return new ApplicationConfigReader();
}

/* Creating a bean for the Message queue Exchange */
@Beanpublic TopicExchange getApp1Exchange() {
return new TopicExchange(getApplicationConfig().getApp1Exchange());
}

/* Creating a bean for the Message queue */
@Beanpublic Queue getApp1Queue() {
return new Queue(getApplicationConfig().getApp1Queue());
}

/* Binding between Exchange and Queue using routing key */
@Beanpublic Binding declareBindingApp1() {
return BindingBuilder.bind(getApp1Queue()).to(getApp1Exchange()).with(getApplicationConfig().getApp1RoutingKey());
}

/* Creating a bean for the Message queue Exchange */
@Beanpublic TopicExchange getApp2Exchange() {
return new TopicExchange(getApplicationConfig().getApp2Exchange());
}

/* Creating a bean for the Message queue */
@Beanpublic Queue getApp2Queue() {
return new Queue(getApplicationConfig().getApp2Queue());
}

/* Binding between Exchange and Queue using routing key */
@Beanpublic Binding declareBindingApp2() {
return BindingBuilder.bind(getApp2Queue()).to(getApp2Exchange()).with(getApplicationConfig().getApp2RoutingKey());
}

/* Bean for rabbitTemplate */
@Beanpublic RabbitTemplate rabbitTemplate(final ConnectionFactory connectionFactory) {
final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMessageConverter(producerJackson2MessageConverter());
return rabbitTemplate;
}

@Beanpublic Jackson2JsonMessageConverter producerJackson2MessageConverter() {
return new Jackson2JsonMessageConverter();
}

@Beanpublic MappingJackson2MessageConverter consumerJackson2MessageConverter() {
return new MappingJackson2MessageConverter();
}

@Beanpublic DefaultMessageHandlerMethodFactory messageHandlerMethodFactory() {
DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
factory.setMessageConverter(consumerJackson2MessageConverter());
return factory;
}

@Overridepublic void configureRabbitListeners(final RabbitListenerEndpointRegistrar registrar) {
registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory());
}

}

Architect a Message Broker

The MessageSender class is strikingly simple. It harnesses the convertAndSend() method of the RabbitTemplate to channel messages to a queue, defining the exchange, routing key, and data payload.

package com.dpk;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.stereotype.Component;

/


A message broker responsible for relaying messages to a queue via an exchange.
*/


@Componentpublic class MessageSender {

private static final Logger log = LoggerFactory.getLogger(MessageSender.class);

/




@param rabbitTemplate
@param exchange
@param routingKey
@param data
*/
public void sendMessage(RabbitTemplate rabbitTemplate, String exchange, String routingKey, Object data) {
log.info("Routing message to the queue using routingKey {}. Message= {}", routingKey, data);
rabbitTemplate.convertAndSend(exchange, routingKey, data);
log.info("The message has been successfully relayed to the queue.");
}


}

Architecting Message Handlers

Constructing a message handler can be a multifaceted task, as it entails addressing diverse scenarios, including:

Automatically converting messages into Java objects
Managing REST call failures to inaccessible APIs or errors occurring during request processing
Enabling multiple handlers to concurrently retrieve and process messages from queues
Determining when and how to re-queue messages in the event of failure

Java Object Deserialization

Spring provides the @RabbitListener annotation, which simplifies message reception from queues and offers automatic Java object deserialization. The following example demonstrates this feature.

Error Handling and Message Re-Queuing in Handlers

The handler attempts to call an unreachable API to process the request

The handler calls the API, but an error occurs during request processing

In such situations, depending on your business requirements, you may choose not to re-queue the message or re-queue it with a maximum number of retry options to process it up to a limit.

To prevent re-queuing the message, you can throw the AmqpRejectAndDontRequeueException. For maximum retry handling, you can add an additional parameter to the message, setting the maximum number of retries and incrementing its value while receiving the message, ensuring the total number of retries does not exceed the limit.

An alternative approach is to add these properties to the application.properties file, specifying the maximum number of attempts:

spring.rabbitmq.listener.simple.retry.max-attempts=3

Concurrency Capabilities

Concurrency can be achieved in two ways:

Creating a thread pool with a specified maximum number of threads and using a ThreadExecutor to call the methods/APIs for request processing.
Leveraging the built-in concurrency feature, which requires setting two properties in the application.properties file.

Note: You can adjust the values of these properties according to your application’s scalability requirements.

spring.rabbitmq.listener.simple.concurrency=4

spring.rabbitmq.listener.simple.max-concurrency=8

package com.dpk;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpRejectAndDontRequeueException;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import com.dpk.config.ApplicationConfigReader;
import com.dpk.dto.UserDetails;
import com.dpk.util.ApplicationConstant;

/**
 * Message Listener for RabbitMQ
 */

@Servicepublic class MessageListener {

    private static final Logger log = LoggerFactory.getLogger(MessageListener.class);

    @Autowired    ApplicationConfigReader applicationConfigReader;


    /**
     * Message listener for app1
     * @param UserDetails a user defined object used for deserialization of message
     */
    @RabbitListener(queues = "${app1.queue.name}")
    public void receiveMessageForApp1(final UserDetails data) {
    log.info("Received message: {} from app1 queue.", data);

    try {
    log.info("Making REST call to the API");
    //TODO: Code to make REST call
        log.info("<< Exiting receiveMessageForApp1() after API call.");
    } catch(HttpClientErrorException  ex) {

    if(ex.getStatusCode() == HttpStatus.NOT_FOUND) {
        log.info("Delay...");
        try {
    Thread.sleep(ApplicationConstant.MESSAGE_RETRY_DELAY);
    } catch (InterruptedException e) { }

    log.info("Throwing exception so that message will be requed in the queue.");
    // Note: Typically Application specific exception should be thrown below
    throw new RuntimeException();
    } else {
    throw new AmqpRejectAndDontRequeueException(ex); 
    }

    } catch(Exception e) {
    log.error("Internal server error occurred in API call. Bypassing message requeue {}", e);
    throw new AmqpRejectAndDontRequeueException(e); 
    }

    }


    /**
     * Message listener for app2
     * 
     */

    @RabbitListener(queues = "${app2.queue.name}")
    public void receiveMessageForApp2(String reqObj) {
    log.info("Received message: {} from app2 queue.", reqObj);

    try {
    log.info("Making REST call to the API");
    //TODO: Code to make REST call
        log.info("<< Exiting receiveMessageCrawlCI() after API call.");
    } catch(HttpClientErrorException  ex) {

    if(ex.getStatusCode() == HttpStatus.NOT_FOUND) {
        log.info("Delay...");
        try {
    Thread.sleep(ApplicationConstant.MESSAGE_RETRY_DELAY);
    } catch (InterruptedException e) { }

    log.info("Throwing exception so that message will be requed in the queue.");
    // Note: Typically Application specific exception can be thrown below
    throw new RuntimeException();
    } else {
    throw new AmqpRejectAndDontRequeueException(ex); 
    }

    } catch(Exception e) {
    log.error("Internal server error occurred in python server. Bypassing message requeue {}", e);
    throw new AmqpRejectAndDontRequeueException(e); 
    }

    }

}

Set Up the Service Interface

Finally, create the service class that wraps the service interface, which will be triggered by the user. This service class utilizes the MessageSender to forward the message to the queue.

package com.dpk;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.dpk.config.ApplicationConfigReader;
import com.dpk.dto.UserDetails;
import com.dpk.util.ApplicationConstant;


@RestController@RequestMapping(path = "/userservice")
public class UserService {

private static final Logger log = LoggerFactory.getLogger(UserService.class);

private final RabbitTemplate rabbitTemplate;
private ApplicationConfigReader applicationConfig;
private MessageSender messageSender;

public ApplicationConfigReader getApplicationConfig() {
return applicationConfig;
}

@Autowiredpublic void setApplicationConfig(ApplicationConfigReader applicationConfig) {
this.applicationConfig = applicationConfig;
}

@Autowiredpublic UserService(final RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
}

public MessageSender getMessageSender() {
return messageSender;
}

@Autowiredpublic void setMessageSender(MessageSender messageSender) {
this.messageSender = messageSender;
}


@RequestMapping(path = "/add", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> sendMessage(@RequestBody UserDetails user) {

String exchange = getApplicationConfig().getApp1Exchange();
String routingKey = getApplicationConfig().getApp1RoutingKey();

/* Sending to Message Queue */
try {
messageSender.sendMessage(rabbitTemplate, exchange, routingKey, user);
return new ResponseEntity<String>(ApplicationConstant.IN_QUEUE, HttpStatus.OK);

} catch (Exception ex) {
log.error("Exception occurred while sending message to the queue. Exception= {}", ex);
return new ResponseEntity(ApplicationConstant.MESSAGE_QUEUE_SEND_ERROR,
HttpStatus.INTERNAL_SERVER_ERROR);
}

}

}

Conclusion

The complete code is accessible on GitHub, where you can log in and review it at your convenience. Should you have any queries or feedback, please feel free to express your thoughts in the comments section below. I appreciate the chance to interact with you. Thank you!

Unlock Efficient Data Exchange: Import & Export Excel in ASP.NET Core

Ava Parker — Thu, 10 Oct 2024 00:51:09 +0000

This article will guide you through the process of seamlessly importing and exporting Excel files in ASP.NET Core 3.1 Razor Pages. We will cover the following essential topics:

>>  Importing an Excel file in .NET Core and previewing the uploaded file
>>  Exporting the Excel file

NPOI Package: A Powerful Tool for Excel File ManagementNPOI is a versatile, open-source tool that supports xls, xlsx, and docx extensions. As the .NET equivalent of the POI Java project at http://poi.apache.org/, NPOI enables you to read and write XLS, DOC, PPT files. It offers a wide range of features, including styling, formatting, data formulas, and image extraction, among others. A significant advantage of NPOI is that it does not require Microsoft Office to be installed on the server. You can utilize NPOI anywhere, making it a valuable component for your projects. For more information on how to unlock efficient data exchange, check out computerstechnicians.

This post demonstrates the fundamental functionalities of NPOI, but you can accomplish much more with NPOI, such as styling individual cells or rows, creating Excel formulas, and other tasks. The NPOI package supports both “xls” and “xlsx” extensions, utilizing HSSFWorkbook and XSSFWorkbook classes. The HSSFWorkbook class is for “xls”, whereas the other is for “xlsx”. To learn more about NPOI, refer to the official documentation.

Streamlining Excel Import and Export in ASP.NET Core 3.1 Razor Pages

Let’s create a .NET Core web application with .NET Core 3.1. Open VS 2019 ➠ Select ASP.NET Core web application

In this example, we create an input file for uploading the Excel file, and after uploading it, append the Excel data into a DIV. Then, we download that Excel data and also create an Excel file using dummy data. The design is shown below:

Import and Export Excel in ASP.NET Core 3.1 Razor Pages

            <a href="@Url.Action(">Retrieve File</a>

Code Fragment Breakdown

This HTML code fragment integrates a file upload interface and a corresponding upload button. The accompanying jQuery script enables the asynchronous upload of Excel files, while also conducting client-side validation to verify file selection and extension accuracy.

Upon successful completion of the request, the server response is appended to the HTML. For a detailed understanding of handling Ajax requests with ASP.NET Core 3.1 razor pages, refer to this article, and for uploading files in ASP.NET Core 3.1 Razor Pages, consult this resource.

To facilitate file import, create a post method in the Homecontroller.cs file, saving the uploaded file to the wwwroot folder, and subsequently append it to the div.

public ActionResult Import()
        {
            IFormFile file = Request.Form.Files[0];
            string folderName = "UploadExcel";
            string webRootPath = _hostingEnvironment.WebRootPath;
            string newPath = Path.Combine(webRootPath, folderName);
            StringBuilder sb = new StringBuilder();
            if (!Directory.Exists(newPath))
            {
                Directory.CreateDirectory(newPath);
            }
            if (file.Length > 0)
            {
                string sFileExtension = Path.GetExtension(file.FileName).ToLower();
                ISheet sheet;
                string fullPath = Path.Combine(newPath, file.FileName);
                using (var stream = new FileStream(fullPath, FileMode.Create))
                {
                    file.CopyTo(stream);
                    stream.Position = 0;
                    if (sFileExtension == ".xls")
                    {
                        HSSFWorkbook hssfwb = new HSSFWorkbook(stream); //This will read the Excel 97-2000 formats
                        sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
                    }
                    else
                    {
                        XSSFWorkbook hssfwb = new XSSFWorkbook(stream); //This will read 2007 Excel format
                        sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
                    }
                    IRow headerRow = sheet.GetRow(0); //Get Header Row
                    int cellCount = headerRow.LastCellNum;
                    sb.Append("<table class='table table-bordered'><tr>");
                    for (int j = 0; j < cellCount; j++)
                    {
                        NPOI.SS.UserModel.ICell cell = headerRow.GetCell(j);
                        if (cell == null || string.IsNullOrWhiteSpace(cell.ToString())) continue;
                        sb.Append("<th>" + cell.ToString() + "</th>");
                    }
                    sb.Append("</tr>");
                    sb.AppendLine("<tr>");
                    for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++) //Read Excel File
                    {
                        IRow row = sheet.GetRow(i);
                        if (row == null) continue;
                        if (row.Cells.All(d => d.CellType == CellType.Blank)) continue;
                        for (int j = row.FirstCellNum; j < cellCount; j++)
                        {
                            if (row.GetCell(j) != null)
                                sb.Append("<td>" + row.GetCell(j).ToString() + "</td>");
                        }
                        sb.AppendLine("</tr>");
                    }
                    sb.Append("</table>");
                }
            }
            return this.Content(sb.ToString());
        }

To access the file, follow the instructions outlined in the code snippet below:

public ActionResult Download()
        {
            string filePath = "wwwroot/UploadExcel/CoreProgramm_ExcelImport.xlsx";
            byte[] fileBytes = System.IO.File.ReadAllBytes(filePath);
            System.IO.File.WriteAllBytes(filePath, fileBytes);
            MemoryStream ms = new MemoryStream(fileBytes);
            return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, "employee.xlsx");
        }

To create and export the file, let’s leverage sample employee data and export it in a corresponding manner.

public async Task<IActionResult> Export()
        {
            string sWebRootFolder = _hostingEnvironment.WebRootPath;
            string sFileName = @"Employees.xlsx";            string URL = string.Format("{0}://{1}/{2}", Request.Scheme, Request.Host, sFileName);
            FileInfo file = new FileInfo(Path.Combine(sWebRootFolder, sFileName));
            var memory = new MemoryStream();
            using (var fs = new FileStream(Path.Combine(sWebRootFolder, sFileName), FileMode.Create, FileAccess.Write))
            {
                IWorkbook workbook;
                workbook = new XSSFWorkbook();
                ISheet excelSheet = workbook.CreateSheet("employee");
                IRow row = excelSheet.CreateRow(0);

                row.CreateCell(0).SetCellValue("EmployeeId");
                row.CreateCell(1).SetCellValue("EmployeeName");
                row.CreateCell(2).SetCellValue("Age");
                row.CreateCell(3).SetCellValue("Sex");
                row.CreateCell(4).SetCellValue("Designation");

                row = excelSheet.CreateRow(1);
                row.CreateCell(0).SetCellValue(1);
                row.CreateCell(1).SetCellValue("Jack Supreu");
                row.CreateCell(2).SetCellValue(45);
                row.CreateCell(3).SetCellValue("Male");
                row.CreateCell(4).SetCellValue("Solution Architect");

                row = excelSheet.CreateRow(2);
                row.CreateCell(0).SetCellValue(2);
                row.CreateCell(1).SetCellValue("Steve khan");
                row.CreateCell(2).SetCellValue(33);
                row.CreateCell(3).SetCellValue("Male");
                row.CreateCell(4).SetCellValue("Software Engineer");

                row = excelSheet.CreateRow(3);
                row.CreateCell(0).SetCellValue(3);
                row.CreateCell(1).SetCellValue("Romi gill");
                row.CreateCell(2).SetCellValue(25);
                row.CreateCell(3).SetCellValue("FeMale");
                row.CreateCell(4).SetCellValue("Junior Consultant");

                row = excelSheet.CreateRow(4);
                row.CreateCell(0).SetCellValue(4);
                row.CreateCell(1).SetCellValue("Hider Ali");
                row.CreateCell(2).SetCellValue(34);
                row.CreateCell(3).SetCellValue("Male");
                row.CreateCell(4).SetCellValue("Accountant");

                row = excelSheet.CreateRow(5);
                row.CreateCell(0).SetCellValue(5);
                row.CreateCell(1).SetCellValue("Mathew");
                row.CreateCell(2).SetCellValue(48);
                row.CreateCell(3).SetCellValue("Male");
                row.CreateCell(4).SetCellValue("Human Resource");

                workbook.Write(fs);
            }
            using (var stream = new FileStream(Path.Combine(sWebRootFolder, sFileName), FileMode.Open))
            {
                await stream.CopyToAsync(memory);
            }
            memory.Position = 0;
            return File(memory, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", sFileName);
        }

Let's initiate the application and examine the results.

Access the Source Code at Github.com/CoreProgramm/.

Upon uploading the file, it is saved to the specified path. For a more in-depth look, visit the following link:
https://www.coreprogramm.com/2020/01/import-and-export-excel-file-in-dotnet-core.html.

Securing Your Data: Creating Immutable Copies of SQL and MySQL Databases

Top Discounts on Dell's Premium Laptops: Unbeatable Offers on XPS 13, XPS 15, and XPS 17 Models

Unlock 6-Figure Data Science Career in 4 Proven Steps

Ava Parker — Wed, 09 Oct 2024 23:04:31 +0000

In today's data-driven era, businesses are hungry for valuable insights from their vast data reserves. Consequently, the demand for data scientists has soared, making them a vital component of corporate strategy.

This surge in demand has paved the way for an exciting career path in data science, with opportunities to progress from junior to senior levels, including principal data scientist and director, in just a few years.

If you're new to data science and aspire to reach the top, it's crucial to understand the career progression and the skills required to succeed. According to computerstechnicians, a well-planned approach can help you unlock a 6-figure data science career.

Navigating the Data Scientist Career Path

To excel as a data scientist, you need a solid foundation in data science, statistics, and engineering. Here's a typical career path to follow:

Associate/Junior Data Scientist: Level 1.0

As a junior data scientist, your role involves testing new ideas, debugging, and refining existing models. You'll also be expected to collaborate with your team, pitch innovative ideas, and take ownership of improving code quality and impact.

If you're still in college, you can get a head start by developing skills in programming languages like Python, Java, R, and SQL/MySQL, while refreshing your knowledge of applied mathematics and statistics. Early exposure to the field will help you determine if a data science career is right for you.

Focus on subjects like computer science, information technology, mathematics, statistics, and data science to increase your chances of success. You should possess skills in data science, machine learning, Python, R, research, SQL, data analysis, analytical skills, teamwork, and communication skills.

Data Scientists Mid-Level-I Roles: Level 2.0

With one to three years of work experience, you can take your career to the next level as a senior data scientist or machine learning and AI engineer, if AI is your area of interest. At this stage, certifications in data science can give you a competitive edge, so it's recommended to earn one or two relevant certifications.

Senior Data Scientist

As a senior data scientist, you're expected to develop well-designed products that meet the highest standards. Seasoned professionals in this field avoid rookie mistakes, eliminate logical flaws in models, and refine high-performing systems. They write reusable code, build robust data pipelines in the cloud, and prepare impeccable data. Additionally, they mentor junior colleagues and provide insightful answers to business questions for top management.

Many seasoned data scientists boast a Master's degree, while others have even earned a Ph.D. and obtained senior data scientist certification, underscoring their expertise.

AI/Machine Learning Engineer

Data scientists must tap into the vast potential of Machine Learning and Artificial Intelligence (AI), which are rapidly advancing fields. As machine learning becomes a core mission for organizations, data scientists must develop end-to-end machine learning solutions. This involves designing, creating, evaluating, and deploying models to production, monitoring and logging decisions, and visualizing data to drive business outcomes.

To excel, you'll need to possess in-depth knowledge and skills in Artificial Intelligence, Deep Learning, Machine Learning, Natural Language Processing, Data Science, Python, C++, SQL, Java, and software engineering. Obtaining Machine Learning or Artificial Engineering certifications, in addition to top-tier data scientist certifications, is highly prized.

Data Scientists Mid-Level-II Roles: Level 3.0

In this mid-tier level, soft skills take center stage. You should be both tech-savvy and business-savvy, with a profound understanding of business and various data analytics technologies. You'll need to apply methods to validate data, prevent fraud, and manage budgets. It's essential to understand parallelization, scalability, and complexity analysis. You'll shape data products to align with corporate strategy and provide data insights that inform business decisions, driving growth and revenue.

Principal Data Scientist

The Principal Data Scientist is the most seasoned member of the data science team, with over 5 years of experience and expertise in data science models. They focus on high-impact business projects and often hold a Ph.D. and principal data scientist certification. The Principal Data Scientist (PDS) leverages their machine learning expertise to provide strategic direction at scale, driving business transformation.

They're expected to understand challenges across multiple business domains, identify new business opportunities, and demonstrate leadership excellence in data science methodologies. They must also possess scientific and industrial maturity, delivering designs and algorithms that make and quantify cross-organization trade-offs, driving business value.

In addition to their core responsibilities, Principal Data Scientists (PDS) play a vital role in mentoring junior colleagues, serving as technical advisors to product managers, and are highly valued in any data science project, driving business success.

Executive Data Science Positions

This high-level role demands proficiency in both database management systems and programming languages. Data Science Leaders/Architects spearhead teams, establish priorities, and present insights to senior management.

Many possess certifications such as Microsoft Certified Professional, Certified Analytics Professional, or SAS/SQL certified practitioner, depending on their organization’s requirements. A Master’s in Business Administration is often recommended for this role, which involves team leadership and project management.

Senior Data Science Positions: Level 4.0

To attain this level, professionals must demonstrate the ability to mentor teams, oversee strategic data analysis, and stay current with the latest technologies. Directing an organization’s entire data science operations is a fulfilling challenge that requires the right blend of skills. The director’s decisions have a profound impact on the organization’s success or failure.

Core Insights

Pursuing a data scientist career is an exciting, challenging, and rewarding journey. To thrive, acquire in-depth knowledge to become a top associate. Be prepared to deploy models into production to become a senior. Continuously assess and upgrade your skills, and strive to make data work for you and your organization.

Unlock 100s of Microservices in 5 Easy Steps with Spring Cloud Config & Kotlin!

Ava Parker — Mon, 07 Oct 2024 22:17:10 +0000

Building a microservice architecture with Java and Spring Boot has gained immense popularity in recent years. However, managing hundreds of services for each profile can be a daunting task. In this article, we will delve into the world of Spring Cloud Config Server using Kotlin, a powerful tool that simplifies this process.

Spring Boot has revolutionized Spring projects, offering a much-needed boost in terms of efficiency and productivity.

Spring Cloud Config provides a unified and flexible approach to external configuration in a distributed environment. With the Config Server, you have a single point to manage external properties for applications across all environments, making it an essential tool for any microservice setup.

As illustrated in the diagram above, managing configuration as a central service in distributed systems can be a complex task. Spring Cloud Config provides a client-server architecture mechanism to simplify this process, making it an ideal solution for managing hundreds of services.

Let’s visit https://start.spring.io/, a popular platform for building Spring-based applications.

Whenever we make changes to any service, we need to restart the services to apply the changes, which can be time-consuming and inefficient.

Let’s create a Git repository to manage our configuration, a crucial step in building a microservice architecture. To achieve this, we’ll create a Git repository, which will serve as a central hub for our configuration.

So, we’ll create a small Spring Boot microservice called “springbootclient” to read the username from the Spring Cloud Config central configuration server system, which is our Git repository. This approach allows us to manage our configuration in a centralized and efficient manner.

We have created three distinct properties files for each of our different environments:

springbootclient.properties
springbootclient-dev.properties
springbootclient-prod.properties

For a more detailed example, you can visit carsnewstoday, which provides a comprehensive guide to building a microservice architecture using Spring Cloud Config and Kotlin.

https://github.com/maheshwarLigade/cloud-common-config-server

Here, you can find our Spring Cloud Config properties. You can clone or use this repository directly, which will give you a head start in building your microservice architecture.

Now that we have created a Spring Config Server application using Spring Starter, let’s download and import the project into your preferred IDE or editor. The Git repository is used to store our configuration, and the Spring Cloud Config Server application serves these properties to the client, making it an essential tool for managing hundreds of services.

In essence, Git operates as a central data storage, whereas Spring Cloud Config Server assumes the role of a server-side application, providing configuration support to multiple microservices.

Having established our Git data storage, we have developed a sample client application, dubbed springbootclient, within this repository. In our forthcoming microservice article, we will utilize the same Spring Cloud Config as a configuration server.

Let us delve into the code base for the client application.

This is a sample application.properties file:

server.port=8888
logging.level.org.springframework.cloud.config=DEBUG
spring.cloud.config.server.git.uri=https://github.com/maheshwarLigade/cloud-common-config-server.git
spring.cloud.config.server.git.clone-on-start=true
spring.cloud.config.server.git.searchPaths=springbootclient

Example Code for SpringCloudConfigServerexApplication.kt

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.cloud.config.server.EnableConfigServer

@SpringBootApplication@EnableConfigServerclass SpringCloudConfigServerexApplication

fun main(args: Array<String>) {
   runApplication<SpringCloudConfigServerexApplication>(*args)
}

Now, start and initialize the spring cloud-config server and verify the following URL:

http://localhost:8888/springbootclient/dev/master

Configuring a Spring Boot Client Application

Let’s develop a compact microservice that fetches configuration from the spring cloud config server and exposes the property value via a REST endpoint.

Visit https://start.spring.io/ and create a spring boot client microservice using Kotlin.

Sample POM.xml dependencies.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
   <groupId>com.fasterxml.jackson.module</groupId>
   <artifactId>jackson-module-kotlin</artifactId>
</dependency>
<dependency>
   <groupId>org.jetbrains.kotlin</groupId>
   <artifactId>kotlin-reflect</artifactId>
</dependency>
<dependency>
   <groupId>org.jetbrains.kotlin</groupId>
   <artifactId>kotlin-stdlib-jdk8</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Now check the SpringCloudClientAppApplication.kt code

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplicationclass SpringCloudClientAppApplication

fun main(args: Array<String>) {
    runApplication<SpringCloudClientAppApplication>(*args)
}

Now create one sample REST controller which is serving REST request. We want to check ” /whoami” this endpoint is returning which is the user based on active profile dev, prod, etc.

UserController.kt

import org.springframework.beans.factory.annotation.Value
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController


@RestControllerclass UserController {

    @Value("\${app.adminusername}")    var username="Test"
//get request serving
    @GetMapping("/whoami")    fun whoami() = "I am a  "+ username

}

Create a bootstrap.properties file to configure the Spring Cloud Config server settings, specifying the Git branch and active profile, such as development, local, production, and more.

spring.application.name=springbootclient
spring.profiles.active=dev
spring.cloud.config.uri=http://localhost:8888
spring.cloud.config.fail-fast=true
spring.cloud.config.label=master

Each property is intuitively named, clearly indicating its purpose and function.

When accessing this URL http://localhost:9080/whoami

Response: I am a DevUser

Github repository link:

Config Server repository: https://github.com/maheshwarLigade/cloud-common-config-server

Code repository: https://github.com/maheshwarLigade/spring-cloud-config-kotlin-ex

Unlock 100% Persistent Storage for Docker Containers in 5 Steps

Ava Parker — Mon, 07 Oct 2024 20:26:59 +0000

In an ideal scenario, Docker containers should be ephemeral and independent of external storage. This is achievable in microservice architecture when services connect to external databases, queues, and other services. However, certain services like Jenkins, Prometheus, or Postgres require persistent storage, making it essential to set up a reliable storage solution.

Fortunately, attaching EBS volumes to ECS Tasks using Docker volume drivers is now a straightforward process. This article will guide you through the step-by-step process of setting up persistent storage for your Docker containers, ensuring that your ECS Task automatically detaches and reattaches when it restarts. For more information on Docker container storage, visit https://computerstechnicians.com.

Understanding Persistent Storage in ECS

By default, ECS Tasks have a temporary storage area on the host instance, known as the ECS Container Instance, which is essentially an EC2 instance. While this is suitable for temporary data, it's not ideal for persistent storage. To overcome this limitation, we need to connect to external storage solutions like AWS EBS or AWS EFS.

Docker volume plugins, such as REX-Ray, enable us to achieve persistent storage. The REX-Ray plugin can configure AWS services, including creating volumes and attaching them to EC2 instances.

As shown in the diagram below, when an ECS Task runs on an EC2 Instance, the volume (e.g., EBS) needs to be attached to that instance:

REX-Ray simplifies the process by:

creating the volume if it doesn’t already exist, including configuring volume type and size
ensuring our Docker container/ECS Task is mounted with the volume
detaching and re-attaching the volume when the ECS Task moves from one EC2 instance to another

ECS Launch Types

ECS offers two launch types: EC2 and Fargate. With EC2, you are responsible for provisioning the underlying EC2 instances on which your ECS Tasks will be deployed. With Fargate, you only need to specify the CPU and memory requirements, and AWS provisions everything needed to run your ECS Task.

It's essential to note that persistent storage is only compatible with the EC2 launch type, not with Fargate. Therefore, in this article, we will focus solely on the EC2 launch type.

Fix Nulls in 2 Mins: Cleaner JSON Data with Jolt Code

Ava Parker — Sun, 06 Oct 2024 23:37:15 +0000

Simplifying Big Data Processing: A 2-Minute Jolt Code Fix for Cleaner JSON Data

When working with big data streams, null values can hinder efficient and accurate data processing. In this article, we'll explore the benefits of using Jolt code to eliminate these null values, ensuring a smoother data processing experience.

Jolt code is specifically designed for big data streams, and it's surprisingly easy to use. For instance, you can utilize Jolt to remove null values with the following code:

[
  {
    "operation": "default",
    "spec": {
      "address": "",
      "somesensorvalues[]": {
        "*": {
          "sensor1": false
        }
      },
      "startTime": "",
      "onStartTime": "",
      "markId": "",
      "markName": "",
      "stoppedTime": "",
      "startTime2": "",
      "powerSetting": "false",
      "speed": 0,
      "id": 0,
      "city": "",
      "state": ""
    }
  },
  {
    "operation": "shift",
    "spec": {
      "*": "&"
    }
  }
]

To put this concept into perspective, let's consider an example of source data:

{
  "address" : "2000 Electric Avenue",
  "somesensordata" : [ {
    "sensor1" : null
  } ],
  "city" : "hightstown",
  "deviceId" : 5454545,
  "dateTime" : "2017-08-07 14:56:09",
  "id" : 6831491,
  "idle" : false,
  "startTime" : null,
  "onStartTime" : null,
  "markId" : null,
  "markName" : null,
  "zipCode" : "08520"
}

By applying Jolt code to remove null values, you can significantly improve the efficiency and accuracy of your big data processing. For more insights on streamlining big data, check out t8tech.

Unlock Mule Flows: Send SOAP & Transport Headers Like a Pro

Ava Parker — Sun, 06 Oct 2024 23:19:28 +0000

Unlock the Power of Mule Flows: Learn How to Send SOAP and Transport Headers Like a Pro

As a seasoned MuleSoft expert, I recently led API implementations for a prominent client using MuleSoft's CloudHub. One common requirement that emerged was the need to integrate an external web service into Mule flows. The MuleSoft HTTP Request Connector and Web Service Consumer are the go-to connectors for developers seeking to tap into external web services from Mule flows. When making HTTP requests to an external web service, these connectors require configuration with all requisite parameters, including endpoint URL, HTTP method/operations, headers, and authentications.

In this article, I will explore the process of sending headers (SOAP headers and transport headers) when invoking external web services from Mule flows.

Sending SOAP Headers

When consuming external SOAP services from a Mule flow, we can transmit SOAP headers to the external web service by leveraging the MuleSoft property transformer. To do this, we need to establish outbound properties with the prefix "soap." using the MuleSoft property transformer. Outbound properties that commence with a "soap." prefix will be treated as SOAP headers and disregarded by the transport. Conversely, all properties that aren't named with a "soap." prefix will be treated as HTTP transport headers (by default, the WSC employs the HTTP transport).

For example, we can use the MuleSoft property transformer to create a SOAP header named "cccmoiheaders." The value of these headers can be static or dynamic (by reading from flowVars or property placeholders).

To learn more about sending SOAP and transport headers in Mule flows, check out this in-depth guide: https://t8tech.com/it/architecture/unlock-the-power-of-mule-flows-learn-how-to-send-soap-and-transport-headers-like-a-pro/

<set-property propertyName="soap.cccmoiheaders" value="&lt;wsse:Security

xmlns:soapenv=&quot;http://schemas.xmlsoap.org/soap/envelope/&amp;quot;

xmlns:wsu=&quot;http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd&amp;quot;

xmlns:wsse=&quot;http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd&amp;quot; soapenv:mustUnderstand=&quot;1&quot;&gt;&lt;

    wsse:UsernameToken wsu:Id=&quot;UsernameToken-03184DA938DBE5406314344062579892&quot;&gt;&lt;wsse:Username&gt;${BW.UserName}&lt;/wsse:Username&gt;&lt;

    wsse:Password Type=&quot;http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText&amp;quot;&amp;gt;${BW.Password}&amp;lt;/wsse:Password&amp;gt;&amp;lt;

    /wsse:UsernameToken&gt;&lt;/wsse:Security&gt;" 

doc:name="BW_Headers"/>

The output of this code snippet will generate a SOAP header named “cccmoiheaders” with the value below.

<wsse:Security

            xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"

            xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"

            xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" soapenv:mustUnderstand="1">

            <wsse:UsernameToken wsu:Id="UsernameToken-03184DA938DBE5406314344062579892">

                        <wsse:Username>abcddddd</wsse:Username>

                        <wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">absbbsbs</wsse:Password>

            </wsse:UsernameToken>

</wsse:Security>

2. Customizing Transport Headers: When integrating Mule flows with external web services (REST via HTTP Connector or SOAP via Web Service Consumer), various options are available for sending transport headers. Let's delve into the process of transmitting transport-level headers from Mule flows when utilizing these connectors to invoke external web services.

2.1 Utilizing the Web Service Consumer: To transmit transport-level headers while consuming an external SOAP service using the WS Consumer, MuleSoft's property transformer is the optimal solution. Here, we need to establish outbound properties (excluding the “soap.” prefix) using the MuleSoft property transformer prior to the WS Consumer. These outbound properties will be treated as transport headers (by default, the WSC employs the HTTP transport).

The following code snippet will create a transport header named “Content-Type” with the value “application/json”:

     <set-property propertyName="Content-Type" value="application/json" doc:name="Property"/>

2.2 Harnessing the Power of the HTTP Request Connector: When integrating external web services via the HTTP Request Connector, you can transmit transport-level headers by leveraging the MuleSoft property transformer (as outlined in section 2.1) or by explicitly defining the transport headers within the HTTP Request Connector's configuration settings. Outbound properties present in the Mule message that reaches the HTTP Request Connector are automatically appended as HTTP request headers. The screenshot below illustrates the header configuration in the HTTP Requester Configuration, where the header values are static, but can be dynamically retrieved from flowVars or a property placeholder.

The approaches outlined above play a crucial role in sending headers when invoking external web services from a Mule flow. Furthermore, in Mule flows, you can replicate all existing properties from the inbound scope to the outbound scope of the message using the “copy-properties” feature. Please refer to the code snippet below for configuring copy-properties in Mule.

<copy-properties propertyName="http.*" doc:name="Copy All HTTP Headers"/>

Let’s share our expertise to enrich our MuleSoft community.

Thank you!

Boost Your iOS App's Speed: 7 Essential Performance Testing Tips

Ava Parker — Sun, 06 Oct 2024 23:08:17 +0000

In the cutthroat world of iOS app development, speed is the name of the game. With users having no patience for slow and unresponsive apps, it's crucial to evaluate an app's performance before its release. A single misstep can lead to a poor user experience, ultimately affecting an app's success.

At Apple's 2014 Worldwide Developers Conference (WWDC), the tech giant introduced performance testing support for the XCTest framework. This framework allows developers to measure code performance within unit or UI tests. In this article, we'll explore the process of conducting automated performance testing using the XCTest framework, a game-changer in the world of iOS development.

The Evolution of Performance Testing in iOS

Apple provides a range of developer tools to assess the performance of iOS apps, including Instruments, Leaks, Profiler, and Allocations. These tools help detect performance issues, memory leaks, and other bottlenecks. However, traditional manual monitoring and execution of these checks are no longer viable in modern iOS development. With a single code change capable of rendering an app unresponsive, unstable, and unusable, an automated approach is necessary to regularly evaluate an app's performance. Fortunately, there are ways to achieve automated performance testing of iOS apps, such as:

Scheduling periodic Instruments checks.
Implementing automated performance tests using the XCTest framework, a more efficient approach.

In this article, we'll delve into automated performance tests using the XCTest framework, as regular Instruments checks are not a suitable solution due to the repetitive nature of the task. For more information on ongoing quality assurance of iOS applications, visit https://carsnewstoday.com.

Streamlining Performance Testing with XCTest

The XCTest framework features measure blocks that can be applied to any code within a test method to evaluate its performance. Here's how it works:

The measure block executes the code multiple times, depending on the set number of invocations – the default being ten.
Upon completion, it calculates the average value, which can be used as a baseline for future test executions. This baseline value can also be set manually.
The performance test will fail if the average time exceeds the baseline.

Applying Performance Tests at the UI Level

Identifying suitable candidates for performance testing is a team-based decision. While XCTest documentation suggests that performance tests can be applied to any XCTest, regardless of the test level, we'll focus on XCUItests for this demo. This approach enables communication with all application endpoints, providing an opportunity to analyze which service or API responds faster or slower. Applying performance tests to UI tests has its advantages and disadvantages. While XCUItests cover diverse areas, the performance test may become exceedingly slow. In contrast, applying performance tests at the unit level yields quick results.

Assessing App Efficiency with Customizable Measurement Tools

To demonstrate this concept in a real-world scenario, let's develop a demo application, XCUItest-Performance, featuring a UI test target. Begin by adding a button to the main storyboard, assigning it the accessibility identifier "press" without linking it to any IBAction. At this point, we will have a functional demo app with a button. In the XCUItest template, create a test specifically designed for performance assessment, incorporating a measure block. Within this block, we can initiate the app launch sequence and simulate a button press. A typical test would resemble the following:

func evaluateAppPerformance() {
    self.measure {
     XCUIApplication().launch()
     XCUIApplication().buttons["press"].tap()
}

We can execute the test from Xcode and observe that it will iterate the code within the block ten times. During the initial test run, it will fail, prompting the developer to establish an appropriate benchmark value for future test executions. The test will subsequently pass or fail based on the comparison of the average value and the benchmark value.

Observe this in the GIF below:

Now that we have established the benchmark value for our future performance tests, these tests will run in tandem with our normal unit tests, failing if the average value exceeds the benchmark. This enables us to automatically test the performance of our code alongside unit test execution.

Refined Performance Tests with Measure Metrics

In the preceding test, we calculated the average time from the app launch until the user presses the button. However, we can delve deeper and specify the exact points from which to start and stop measuring performance. This allows us to apply performance tests to specific areas of the test code within the unit test by utilizing the start/stop method, achievable through the measure metric method.

Let’s apply performance tests solely when the button is pressed. We can launch the app normally and then employ the measure metric method to initiate and terminate performance measurement. We can add the test as follows:

func testperformancemeasuremetrics() {
   xcuiapplication().launch()
   self.measuremetrics([xctperformancemetric.wallclocktime], automaticallystartmeasuring: false) {
      startmeasuring()
      xcuiapplication().buttons["press"].tap()
      stopmeasuring()

   }
}

Upon executing this test, we can observe that the application launches only once, yet we can calculate its performance by invoking it multiple times.

The measure metrics method offers a convenient means of optionally setting up start and end points for performance measurement during test execution, thereby providing valuable insights.

Performance Test Result Analysis

Xcode visually represents the results of performance tests, with a typical result resembling this:

The resulting dialogue reports average, baseline, and max stddev values, indicating that the performance test is 0.779% worse than the previous execution. These results can also be accessed in the console output when running performance tests from a continuous integration server.

Pros and Cons of XCTest as a Performance Test Tool

XCTest, a unit and UI level functional testing tool, is also capable of performing performance testing of iOS modules. However, there are certain advantages and disadvantages to using XCTest as a performance testing tool.

Advantages

Developers can benefit from using XCTest for performance testing in several ways:

As a core Apple framework, XCTest eliminates the need to add third-party dependencies for performance testing, thereby streamlining the process.
Unit tests written using XCTest can be easily extended to performance tests by adding measure blocks around code snippets, eliminating the need to learn additional performance test tools.
Performance tests can be written using Swift, eliminating the need to learn additional languages.
XCTest is easily pluggable to any continuous integration server, allowing for seamless execution using Xcodebuild or Fastlane Scan.
It offers the ability to match the baseline using device types, eliminating the need to worry about comparing results with valid data sets.
XCTest provides the ability to utilize the Xcode IDE for performance testing, making it a convenient option.

Disadvantages

Despite its benefits, using XCTest for performance testing also has some drawbacks:

The performance test results generated by XCTest are not easily interpretable by non-technical individuals, and cannot be exported to a readable format.
The performance test results cannot be shared or hosted easily, unlike other performance test tools.
As the number of performance tests increases, the test suite becomes slower, necessitating separate execution from the development workflow.
XCTest is incapable of simulating a large number of users to check the performance of an iOS app.
XCTest cannot alter hardware device settings like CPU or memory to cover complex behaviors for performance tests.

Mastering Performance Testing: Expert Techniques for Optimal Results

In Xcode, performance tests are seamlessly integrated with unit and UI tests via the XCTest framework. Consequently, developers must ensure that their tests are properly configured and functioning as intended. When setting up performance tests, several crucial factors come into play:

Establish Clear Testing Objectives

Before initiating performance testing, it's vital to define what and how specific code will be evaluated for performance. Identifying the testing level – whether unit, integration, or UI – is also essential. Fortunately, the XCTest framework allows for testing at any level.

Prevent Interference Between Test Iterations

Performance tests involve executing multiple iterations of the same code block. Ensuring that each iteration is self-contained and independent, with minimal deviation, is critical. Xcode will flag any significant deviations as errors.

Optimize Test Data for Reliable Results

Predefined test data is more likely to yield consistent results compared to random data when running performance tests. Random data can produce erratic results, which are of limited value.

Execute Performance Tests in a Dedicated Scheme

As the number of performance tests grows, test suite execution time increases substantially. Configuring a separate scheme to run only performance tests, without impacting unit and UI tests, is a practical solution.

Integrate Performance Tests into Your CI Workflow

With a dedicated scheme in place, integrating performance tests into your continuous integration server is relatively straightforward. If you're using the Xcode server, the process is even simpler. Create a separate CI job to run performance tests regularly, such as daily or overnight.

Access the Demo Source Code

The source code for the performance test discussed in this article is available on GitHub. Clone the repository and try running performance tests yourself.

GitHub repo: xctest-performance

Conclusion

Apple's extension of the XCTest framework for performance testing enables developers to identify performance bottlenecks early in the development cycle. With the latest Xcode, getting started with performance testing is easier than ever. We encourage you to try this approach and integrate performance tests into your iOS apps soon!

DEV Community: Ava Parker

Boost Testing Speed: Master Sanity vs Regression Today!

Unlocking Sanity Testing: Its Essence and Guidelines for Effective Implementation

The Rationale Behind Sanity Testing

Streamline Dev in 10 Steps: Publish Artifacts with Jenkins & Nexus

Unlock 4 Essential Quartz Scheduler Plugins to Skyrocket Productivity!

LoggingTriggerHistoryPlugin: Uncover the Secrets of Job Execution

LoggingJobHistoryPlugin

XMLSchedulingDataProcessorPlugin

ShutdownHookPlugin

94% of Workloads Will Be in Cloud by 2021: Expert Insights to Avoid Costly Mistakes

Best Practices for a Smooth Cloud Migration

Develop a Comprehensive Cloud Migration Strategy

Evaluate Cloud Computational Models to Find the Best Fit

Tap into the Expertise of Seasoned IT Professionals

Consider the Consequences: Risk and Compliance Factors

Pitfalls to Avoid

Don't Overlook Critical Elements

Security Should Never Be Compromised

Avoid the "One-Size-Fits-All" Approach

The Pivotal Function of Governance Frameworks

Key Takeaways

Unlock Scalable Messaging: 4-Step Guide to Fault-Tolerant Concurrency with RabbitMQ & Spring Boot

Getting Started with RabbitMQ in Your Spring Boot Project

Configure and Initialize Application Properties

Develop a Properties File Reader Class

Lay the Groundwork for Queue, Exchange, Routing Key, and Binding Configurations

Architect a Message Broker

Architecting Message Handlers

Java Object Deserialization

Error Handling and Message Re-Queuing in Handlers

Concurrency Capabilities

Set Up the Service Interface

Conclusion

Unlock Efficient Data Exchange: Import & Export Excel in ASP.NET Core

Streamlining Excel Import and Export in ASP.NET Core 3.1 Razor Pages

Import and Export Excel in ASP.NET Core 3.1 Razor Pages

Code Fragment Breakdown

Securing Your Data: Creating Immutable Copies of SQL and MySQL Databases

Top Discounts on Dell's Premium Laptops: Unbeatable Offers on XPS 13, XPS 15, and XPS 17 Models

Recommended Reading

Unlock Angular’s Full Potential: Inject Services with Ease in 5 Minutes!

Leave a Reply Cancel reply

Unlock 6-Figure Data Science Career in 4 Proven Steps

Navigating the Data Scientist Career Path

Associate/Junior Data Scientist: Level 1.0

Data Scientists Mid-Level-I Roles: Level 2.0

Senior Data Scientist

AI/Machine Learning Engineer

Data Scientists Mid-Level-II Roles: Level 3.0

Principal Data Scientist

Executive Data Science Positions

Senior Data Science Positions: Level 4.0

Core Insights

Unlock 100s of Microservices in 5 Easy Steps with Spring Cloud Config & Kotlin!

Configuring a Spring Boot Client Application

Unlock 100% Persistent Storage for Docker Containers in 5 Steps

Understanding Persistent Storage in ECS

ECS Launch Types

Fix Nulls in 2 Mins: Cleaner JSON Data with Jolt Code

Simplifying Big Data Processing: A 2-Minute Jolt Code Fix for Cleaner JSON Data

Unlock Mule Flows: Send SOAP & Transport Headers Like a Pro

Boost Your iOS App's Speed: 7 Essential Performance Testing Tips

The Evolution of Performance Testing in iOS

Streamlining Performance Testing with XCTest

Applying Performance Tests at the UI Level

Assessing App Efficiency with Customizable Measurement Tools

Refined Performance Tests with Measure Metrics

Performance Test Result Analysis

Pros and Cons of XCTest as a Performance Test Tool

Advantages

Disadvantages

Mastering Performance Testing: Expert Techniques for Optimal Results

Establish Clear Testing Objectives

Prevent Interference Between Test Iterations

Optimize Test Data for Reliable Results

Execute Performance Tests in a Dedicated Scheme

Integrate Performance Tests into Your CI Workflow

Access the Demo Source Code

Conclusion