Author: Mandakinee

How to Install & Configure Redis-Server on Centos/Fedora Server

Posted on by Mandakinee

‘Redis’ is an Open source key-value data store, shared by multiple processes, multiple applications, or multiple Servers. Key values are more complex types like Hashes, Lists, Sets or Sorted Sets.

Let’s have a quick look on the installation steps of “Redis”

Here we go…

Step – 1

First of all we need to switch to superuser & install dependencies:

[code language=”html”]
su
yum install make gcc wget tcl
[/code]

Step-2
Download Redis Packages & Unzip. This guide is based on installing Redis 2.8.3:

[code language=”html”]
wget http://download.redis.io/releases/redis-2.8.3.tar.gz
tar xzvf redis-2.8.3.tar.gz
[/code]

Step-3
Compiling and Installing Redis from the source:

[code language=”html”]
cd redis-2.8.3
make
make install
[/code]

Step- 4

Starting Redis server by executing the following command without any argument:

[code language=”html”]
redis-server
[/code]

Step-5

Check if Redis is working. To check, send a PING command using redis-cli. This will return ‘PONG’ if everything is fine.

[code language=”html”]
redis-cli ping
PONG
[/code]

Step-6

Add Redis-server to init script. Create a directory to store your Redis config files & data:

[code language=”html”]
mkdir -p /etc/redis
mkdir -p /var/redis
[/code]

Also we need to create a directory inside “/var/redis” that works as data &  a working directory for this Redis instance.

[code language=”html”]
mkdir /var/redis/redis
[/code]

Step-7

Copy the template configuration file you’ll find in the root directory of Redis distribution into /etc/redis/

[code language=”html”]
cp redis.conf /etc/redis/redis.conf
[/code]

Edit the configuration file, make sure to perform the following changes:

  • Set daemonize to yes (by default it’s set to ‘No’).
  • Set the pidfile to /var/run/redis.pid
  • Set your preferred loglevel
  • Set the logfile to /var/log/redis.log
  • Set the dir to /var/redis/redis
  • Save and exit from the editor

Step-8 
Add the Redis init script.

[code language=”html”]
vi /etc/init.d/redis
[/code]

And paste the following codes to it

[code language=”html”]
#!/bin/sh
#
# chkconfig: 345 20 80
# description: Redis is an open source (BSD licensed), in-memory data structure store, used as database, cache and message broker.

# Source function library.
. /etc/init.d/functions

REDISPORT=6379
EXEC=/usr/local/bin/redis-server
CLIEXEC=/usr/local/bin/redis-cli

PIDFILE=/var/run/redis.pid
CONF="/etc/redis/redis.conf"

case "$1" in
start)
if [ -f $PIDFILE ]
then
echo "$PIDFILE exists, process is already running or crashed"
else
echo "Starting Redis server…"
$EXEC $CONF
fi
;;
stop)
if [ ! -f $PIDFILE ]
then
echo "$PIDFILE does not exist, process is not running"
else
PID=$(cat $PIDFILE)
echo "Stopping …"
$CLIEXEC -p $REDISPORT shutdown
while [ -x /proc/${PID} ]
do
echo "Waiting for Redis to shutdown …"
sleep 1
done
echo "Redis stopped"
fi
;;
restart)
stop
start
;;
*)
echo "Please use start or stop as first argument"
;;
esac
exit 0
[/code]

Save the file and exit from the editor.

Step-9
Give appropriate permission to the init script

[code language=”html”]
chmod u+x /etc/init.d/redis
[/code]

Step-10
To run the Redis server at startup we need to add it to the chkconfig list.

[code language=”html”]
chkconfig –add redis
chkconfig –level 345 redis on
[/code]

Step-11
Finally we are ready to start the Redis Server.

[code language=”html”]
/etc/init.d/redis start
[/code]

The redis server will start automatically on system boot.

Conclusion:

‘Redis’ also supports datatypes such as Transitions, Publish and Subscribe. ‘Redis’ is considered more powerful than ‘Memcache’. It would be smart to bring ‘Redis’ into practice and put ‘Memcache’ down for a while.

We provide one-stop solution by utilizing Redis server with Rails , PHP applications and deploy in cloud services such as AWS to make sure that the application is fully scalable.

You can also check the compression of Memcached vs Redis, to know more information on which one to pick for Large web apps?

Do you have anything to add here? Share your thoughts with comments.

It’s always pleasure to hear from you and for5 any assistance and support on AWS you can write us at info@andolasoft.com.

Mastering J2EE Design Patterns and Navigating Through the Tiers

Posted on by Mandakinee

Design pattern is in general-a repeatable solution to a commonly occurring issue in software designs. These patterns can also be considered as a finished design which can be used directly into the code or a template for how to solve a particular issue.

Object oriented design patterns typically show relationships and interactions between objects or classes, without specifying the final application classes or objects that are involved.

Whereas, algorithms do not offer any details of design patterns, since they resolve computational problems rather than design issues.

On the other hand, pattern specifies a solid solution to a recurring design issues, placing particular process on the context and the surrounding problem as well as the consequences and impact of solution.

This provides a collection of patterns which you can use in the context of designing Java 2 Platform and Enterprise Edition (J2EE) applications.

Core J2EE Patterns provides more detail on J2EE patterns and is an excellent resource that can be integrated on the website. Developing and designing patterns leverages the developer community’s collective experience by sharing issues and solutions.

A design pattern must capture a problem’s overview and context, a possible option and the solution simultaneously.
In the J2EE application architecture, we can split up design patterns into two categories: general software development patterns and those patterns that overlook specific J2EE challenges.

J2EE- design pattern verifies lesser known issues which solid application architecture should resolve.

Reasons to implement Patterns:

  • Patterns reflect the knowledge, experience and insights of developers who have smoothly used these patterns in their own work.
  •  Patterns provide a rough solution as necessary that can be adapted to different problems.
  • Patterns provide a generic vocabulary of solutions that can express heavy solutions succinctly.

Understanding J2EE Design Patterns

J2EE Design Patterns are tried-and-tested solutions to recurring design problems encountered in enterprise application development.

These patterns provide a structured approach to solving specific challenges and promote code reusability, modularity, and maintainability. Some common J2EE design patterns include:

  • MVC (Model-View-Controller):
    Separates the application into three components—Model (data logic), View (user interface), and Controller (flow control)—enhancing maintainability and flexibility.
  • DAO (Data Access Object):
    Abstracts the interaction with databases, providing a centralized and consistent way to manage data access.
  • Singleton:
    Ensures that a class has only one instance and provides a global point of access to it, beneficial for managing shared resources.
  • Facade:
    Provides a unified interface to a set of interfaces in a subsystem, simplifying complex systems for clients.
  • Observer:
    Defines a dependency between objects, ensuring that when one object changes state, its dependents are notified and updated automatically.

Deciphering the Multi-Tier Architecture

Enterprise applications are often complex and require a structured architecture for effective development and management.

The multi-tier architecture, also known as n-tier architecture, divides an application into distinct layers or tiers, each responsible for a specific aspect of functionality. The common tiers include:

  • Presentation Tier:
    Also known as the client tier, this layer focuses on user interface interactions. It handles user requests, displays information, and captures user input.
  • Business Logic Tier:
    This tier contains the application’s business logic and rules. It processes user input, interacts with databases through the data access layer, and implements the core functionalities of the application.
  • Integration Tier:
    Also known as the middleware tier, this layer handles communication between the presentation tier and the business logic tier. It often involves components like Enterprise JavaBeans (EJB) for managing distributed transactions and messaging.
  • Resource Tier:
    This tier represents the data storage and management layer. It includes databases, file systems, and other resources that store and manage application data.

Benefits and Best Practices

Mastering J2EE design patterns and understanding the multi-tier architecture yields several benefits, including:

  • Scalability:
    The modular nature of tiers and the reusable solutions of design patterns make scaling applications more manageable.
  • Maintenance:
    The separation of concerns and code reuse simplify maintenance and updates.
  • Performance:
    Efficient data flow and reduced network overhead contribute to optimal application performance.
  • Team Collaboration:
    J2EE patterns and tier architecture facilitate teamwork by offering a common vocabulary and structured approach.

Common uses of Design Patterns:

  1.  Front Controller is a container to hold common processing logic that occurs within the ‘presentation’ tier and which may otherwise be inaccurately put in the ‘View’.
    A controller handles requests and manages content retrieval, view management, security, navigation, delegating to a Dispatcher component to dispatch to a View.
  2. Business Delegate reduces coupling between remote tiers and provides an entry point for accessing remote services in the ‘Model’.
    A Business Delegate might also cache details data as required to improve performance. A Business Delegate encapsulates a ‘Session Façade’ and manages to one-to-one relationship with that ‘Session Façade’. A Business Delegate invokes a ‘Session Façade’ for An Application Services.
  3.  Service Locator encapsulates the implementation mechanisms for looking up business service details. A Service Locator used by a ‘Business Delegate’ connects to a ‘Session Façade’. Other services like web services and business-tier services can use a Service Locator.
  4. Session Façade provides coarse-grained services to the clients by hiding the complexities of the business service interactions. A ‘Session Façade’ might call several Application Service implementations or Business Objects. A ‘Session Façade’ can also encapsulate a Value List Handler.
  5. Business Object implements your conceptual domain model using an object model. Business Objects differentiates business logic and data into a separate layer in the application. Business Objects programmatically represents persistent objects and can be transparently continued using Domain Store.
  6. Data Access Object enables loose coupling between the resources and business tiers. ‘Data Access Object’ covers all the data access logic into CRUD data from a persistent store. ‘Data Access Object’ does work on ‘Transfer Object’ to send and receive data.

Conclusion:

These design patterns captures potential problems when using the various J2EE-specified technologies and supports developers to construct application architecture’s requirements. For example-The locality Front Controller design pattern, transforms unstructured servlet codes into a controller of the refined graphical user interface.

 

Related Questions

What are J2EE Design Patterns and why are they important in enterprise application development?

J2EE Design Patterns are reusable solutions to common design problems encountered in enterprise application development.

They promote code reusability, modularity, and maintainability by offering structured approaches to solving challenges. J2EE Design Patterns ensure that developers follow best practices, resulting in more robust and scalable applications.

How do J2EE Design Patterns enhance the efficiency of different tiers in the multi-tier architecture?

J2EE Design Patterns seamlessly complement the multi-tier architecture. For example, patterns like MVC enhance user interface management in the presentation tier, while patterns like Business Delegate optimize communication between the presentation and business logic tiers. T

hese patterns ensure that each tier is well-structured, efficient, and interacts seamlessly with other tiers.

What is the significance of the multi-tier architecture in enterprise application development?

The multi-tier architecture divides an application into distinct layers, each with specific responsibilities. This structure enhances scalability, maintainability, and performance.

The presentation tier focuses on user interface, the business logic tier handles core functionalities, the integration tier manages communication, and the resource tier deals with data storage and management.

How do J2EE Design Patterns contribute to the scalability of enterprise applications?

J2EE Design Patterns promote modular and reusable code, which simplifies scaling. With patterns like Singleton and Data Access Object (DAO), developers can efficiently manage shared resources and data access, ensuring that as the application grows, it can be scaled without sacrificing performance or complexity.

Can you provide an example of how a J2EE Design Pattern enhances a specific tier in the multi-tier architecture?

Certainly. Consider the MVC pattern. In the presentation tier, the Model-View-Controller (MVC) pattern separates data (Model), user interface (View), and control flow (Controller). This separation enhances maintainability as changes in one component don’t affect the others.

The Controller manages user interactions, the Model handles data logic, and the View renders information. This clear separation simplifies development and updates in the presentation tier.

4 Simple Steps To Implement “Delayed Job” In Rails

Posted on by Mandakinee

Here in this article, I going to tell you the best way to implement “delayed job” in rails

“delayed_job” is a ruby gem used to execute tasks as a background process in Rails environment, increasing page rendering speed.

Delayed::Job (or DJ) allows you to move jobs into the background for asynchronous processing.

Why you need a background process and is it really that important!

Let’s consider a scenario where a mailing application needs to send emails to a huge list of recipients. In such cases it is obvious that the processing time is too long, annoying the users.

Here are some of key points to consider:

  • Incredibly quick & easy to get rolling
  • No addition to your “stack”, runs just fine with Active Record
  • Good choice for beginners while migrating code from foreground to the background

Hence, it’s only wise to move the long running tasks as a background process by using “delayed_job” gem.

Detailed steps to integrate delayed job in a Rails application

Step# 1

  • Add gem to the Gemfile
  • “delayed_job” supports multiple back-ends for storing the job queue
  • To use “delayed_job” with Active Record, use gem ‘delayed_job_active_record’
  • To use “delayed_job” with Mongoid, use gem ‘delayed_job_mongoid’

Example

/Gemfile.rb

  • gem ‘delayed_job_active_record’, ‘4.0.3’
  • Run “bundle install” to install the “delayed_job” gem

Step# 2

  • Generate the related file for the Job run
  • Generate related files required to run the background job by running the following command
    • rails g delayed_job:active_record

It adds following files to the application

  • A Script named “delayed_job” inside “/bin” folder to run the jobs which are in queue.
  • Migration file to create a table to store the job with other information such as priority, attempts, handler, last_error, run_at, locked_at, failed_at, locked_by, queue.

Run the migration file by using the following command

  • rails db:migrate

Set the queue_adapter in config/application.rb

  • config.active_job.queue_adapter = :delayed_job

If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile. If your jobs are failing with:

  • Setup Delayed::Job config in an initializer (config/initializers/delayed_job_config.rb)
    • Delayed::Worker.destroy_failed_jobs = false
    • Delayed::Worker.sleep_delay = 60
    • Delayed::Worker.max_attempts = 3
    • Delayed::Worker.max_run_time = 5.minutes
    • Delayed::Worker.read_ahead = 10
    • Delayed::Worker.default_queue_name = ‘default’
    • Delayed::Worker.delay_jobs = !Rails.env.test?
    • Delayed::Worker.raise_signal_exceptions = :term
    • Delayed::Worker.logger = Logger.new(File.join(Rails.root, ‘log’, ‘delayed_job.log’))

Step# 3

  • Replace script/delayed_job with bin/delayed_job
  • Start up the jobs process

There are two ways to do this.

  • If application is in development mode, we would use the below rake task instead.
    • rake jobs:work
  • If application is in production mode, then it is preferred to use the “delayed_job” script. This demonizes the job process and allows multiple background processes to be spawned.

To use this, pursue the following steps

  • Add gem “daemons” to your Gemfile
  • Run bundle install
  • Make sure you’ve run rails generate delayed_job
  • If you want to just run all available jobs and exit you can use rake jobs:workoff
  • Work off queues by setting the QUEUE or QUEUES environment variable.
    • QUEUE=tracking rake jobs:work
    • QUEUES=mailers,tasks rake jobs:work

Step# 4

  • Add task to run in background
  • In Controller just call .delay.method(params) on any object and it will be processed in the background.

Example:

UsersController before adding to background job

[code language=”html”]
class UsersController < ApplicationController
def send_email
User.find_each(is_subscribed: true) do |user|
NewsMailer.newsletter_mail(user).deliver
flash[:notice] = "Mail delivered"
redirect_to root_path
end
end
end
[/code]

 
UsersController after adding to background job

[code language=”html”]
class UsersController < ApplicationController
def send_email
User.find_each(is_subscribed: true) do |user|
# add .delay method to add it to background process. In case of mail sending remove the .deliver method to make it work.
NewsMailer.delay.newsletter_mail(user)
flash[:notice] = "Mail delivered"
redirect_to root_path
end
end
end
[/code]

Advantages of implementing above steps:

  • No more waiting for a response, after clicking a link to do a big stuff.
  • Just call .delay.method(params) on any object and it processes in the background.
  • Job objects are serialized to yaml and stored in the delayed_jobs table, so they can be restored by the job runner later.
  • It automatically retries on failure. If a method throws an exception it’s caught and the method reruns later. The method retries up to 25 times at increasingly longer intervals until it passes.
  • “delayed_job” gem maintains log by creating a log file “/log/delayed_job.log”

I am sure this article will give you a clear idea about the way to implement “delayed job” in rails. You can share your thoughts with comments if I have missed anything or if you want to know more.

Do you work on or use Ruby on Rails? Let’s Discuss!

Ruby On Rails Releases Fixes For DoS, XSS Vulnerabilities

Posted on by Mandakinee

In 18th March, Ruby on Rails released four new versions along with fixes for a number of vulnerabilities, which could have lead to denial of service attacks and XSS injections. According to a post in company’s blog a total of 4 vulnerabilities were addressed in version 3.2.13, 3.1.12 and 2.3.18 of Rails. The company wrote “All versions are impacted by one or more of these security issues,”

The patches were released for symbol denial service (DoS) vulnerability (CVE-2013-1854) in ActiveRecord function and for two cross-sites scripting vulnerabilities i.e. sanitize helper (CVE-2013-1857) and sanitize_css method in Action Pack (CVE-2013-1855).

According to one of the warnings, an additional XML parsing vulnerability in JDOM backend of ActiveSupport could have also allowed attackers to perform denial of service attack when using JRuby (CVE-2013-1856) or could have enabled to gain access to files stored in the app server.

The XSS vulnerability could have allowed attackers to embed tag URL, which executes arbitrary JavaScript code.

The XSS vulnerabilities in particular could have allowed an attacker to embed a tag containing a URL that executes arbitrary JavaScript code.

Ruby on rails developer have fixed a number of similar issues in Ruby on Rails last month, which also included a YAML issue in ActiveRecord that lead to remote code execution

Apple Promises To Fix The Security Exploit That Lets People Gain Access

Posted on by Mandakinee

In our previous post we had outlined some of the latest features of iOS 6.1 update, mentioning it to be a fix for its old mistakes. But it turns out that, it does have some security flaws which let the users bypass the locked iPhone devices.

Never miss an update from us. Join 10,000+ marketers and leaders.

This exploit was first spotted by a French user who later uploaded a video to YouTube, by demonstrating the procedure to unlock a pass-code protected iOS device.  Seeing this Apple has promised to release a fast fix to this security issue. In a statement, the company said “Apple takes user security very seriously, we are aware of this issue, and will deliver a fix in a future software update.”  But the company has neither offered a specific timeline for its next update nor any quick fix to the handle issue.

The video depicts a sequence of steps in which the French guy easily hacks the “locked” iPhone, that was running iOS 6.1. The process involved is somewhat weird, such as ending an emergency call, consecutive pressing of home button and etc. Below I have provided the exact steps as posted by the users, to unlock the iPhone.

First Part:

  • Go to emergency call, push down the power button and tap cancel.
  • Dial 112 and tap green and immediately red.
  • Go to lock screen.

Second Part:

  • Go to passcode screen.
  • Keep pushing down the power button …1…2…3…seconds and before showing the slider “turn off”…tap the emergency call button and …voilá!
  • Then without releasing the power button press the home button and ready…”

The procedure allows the users to access contacts, photos and to make calls. But it doesn’t offer access to its home screen or any iOS apps that exists on the home screen. The iPhone lock screen hack seems to work on iPhone 4S, iPhone 4 too, if they are running iOS 6.1.

Top 7 Expert Tips And Tricks For IOS 6

Posted on by Mandakinee

iOS 6 is the latest Apple OS that runs on every Apple devices. Its features like friendly user interfaces and the convenience of apps, makes it a smarter operating system.  Perhaps you are an iOS guru. Or maybe a newbie to the operating system, but here we present some tweaks in iOS that you probably never knew. We also hope you love them and enjoy the benefit of this post.

  • Your iPhone Can Read To You:

You can enable the speak option for facilitating the iOS device to read aloud a selected text. You can enable it from the Accessibility option.

Never miss an update from us. Join 10,000+ marketers and leaders.

  • Enable Emoji Keyboard:

Add iconographic symbols in e-mails, messages, tweets and other postings. This feature is shipped with every iOS 6 devise and doesn’t require buying a third-party iPhone application. To get this feature select General, International then Keyboards tab from the settings option.

  • Ask Siri To Find Location By Using The ‘In Transit’ Cue:

You can ask Siri to find you an address by adding some extra word like ‘transit’ in the end of the command. For example “give me the direction to Kennedy International Airport via transit”. iOS will open up the maps apps and display the route.

  • Edit Siri Commands:

Sometimes Siri doesn’t understand your words and might interpret into something else. But you can fix this issue after Siri responds that she doesn’t understand what you’re talking about. Tap the speech bubble where Siri keeps a record of what she interpreted, there find your command, edit it and resubmit the request.

  • Limit The Ad Tracking:

Most users find it annoying to get constant Advertising pop-ups. But iOS allows you limit these accesses as well. Under the General option tap About and then Advertising to Limit the Ad tracking.

  • Take Photos While Shooting Video:

iPhone 5 and iOS 6 allows the users to snap photos and shoot video simultaneously. It appears on the screen in addition to the shutter button.

  • Customize Auto Replies For Rejected Calls:

you can tailor specific messages, explaining the situation why you didn’t answer your calls. By default you will get 3 pre-reserved options. However you can customize these pre-preserved messages too.

I’ve worked with the team at Andolasoft on multiple websites. They are professional, responsive, & easy to work with. I’ve had great experiences & would recommend their services to anyone.

Ruthie Miller, Sr. Mktg. Specialist

Salesforce, Houston, Texas

LEARN MORE

At Andolasoft, our iPhone application developers keep their skills updated with the latest technology and iOS releases to match this competitive market. Here we develop engaging iPhone application to meet our customer’s business requirements.