Friday 21 April 2017

Amazon EC2 Linux instance with desktop functionality from Windows

Amazon EC2 Linux instance with desktop functionality from Windows

This article describes how to connect to an Amazon EC2 Linux instance desktop by using Windows Remote Desktop.

For purposes of this article, make sure that you are running an instance of Ubuntu 14.04 LTS. In addition, this article assumes the user name is 'ubuntu'.

  1. Connect to your Linux instance as described in Connecting to Your Linux Instance from Windows Using PuTTy.
  2. Run the following commands from the terminal to install updates, an upgrade, and install additional packages.
    • sudo apt-get update
    • sudo apt-get upgrade
  3. Because you will be connecting from Windows Remote Desktop, edit the sshd_config file on your Linux instance to allow password authentication.
    • sudo vim /etc/ssh/sshd_config
  4. Change PasswordAuthentication to yes from no, then save and exit.
  5. Restart the SSH daemon to make this change take effect.
    • sudo /etc/init.d/ssh restart
  6. Temporarily gain root privileges and change the password for the ubuntu user to a complex password to enhance security. Press the Enter key after typing the command passwd ubuntu, and you will be prompted to enter the new password twice.
    • sudo –i
    • passwd ubuntu
  7. Switch back to the ubuntu user account and cd to the ubuntu home directory.
    • su ubuntu
    • cd
  8. Install Ubuntu desktop functionality on your Linux instance.
    • export DEBIAN_FRONTEND=noninteractive
    • sudo -E apt-get update
    • sudo -E apt-get install -y ubuntu-desktop
  9. Install XRDP and other xfce4 resources.
    • sudo apt-get install xfce4 xrdp
    • sudo apt-get install xfce4 xfce4-goodies
  10. Make xfce4 the default window manager for RDP connections.
    • echo xfce4-session > ~/.xsession
  11. Copy .xsession to the /etc/skel folder so that xfce4 is set as the default window manager for any new user accounts that are created.
    • sudo cp /home/ubuntu/.xsession /etc/skel
  12. Open the xrdp.ini file to allow changing of the host port you will connect to.
    • sudo vim /etc/xrdp/xrdp.ini
  13. Look for the section [xrdp1] and change the following text (then save and exit [:wq]).
    • port= -1 - to -   port= ask-1
  14. Restart xrdp.
    • sudo service xrdp restart
On Windows, open the Remote Desktop Connection client, paste the fully qualified name of your Amazon EC2 instance for the Computer, and then click Connect.

When prompted to Login to xrdp, ensure that the sesman-Xvnc module is selected, and enter the username ubuntu with the new password that you created in step 7. When you start a session, the port number is -1.

When the system connects, several status messages are displayed on the Connection Log screen. Pay close attention to these status messages and make note of the VNC port number displayed. If you want to return to a session later, specify this number in the port field of the xrdp login dialog box.


Tuesday 11 April 2017

Introducing Apache Beam

Introducing Apache Beam

As part of the Google Cloud ecosystem, Google created Dataflow SDK. Now, as a Google, Talend, Cask, data Artisans, PayPal, and Cloudera join effort, Apache Dataflow is at Apache Incubator.

Architecture and Programming model

Just Imagine, you have a Hadoop cluster where you used MapReduce jobs. Now, you want to “migrate” these jobs to Spark: you have to refactor all your jobs which requires lot of works and cost. And after that, see the effort and cost if you want to change for a new platform like Flink: you have to refactor your jobs again.

Dataflow aims to provide an abstraction layer between your code and the execution run-time.
The SDK allows you to use an unified programming model: you implement your data processing logic using the Dataflow SDK, the same code will run on different back ends(Spark / Flink / etc). You don’t need to refactor and change the code anymore !

If your target back end is not yet supported by Dataflow, you can implement your own runner for this back end, again the code using Dataflow SDK doesn’t change.

Dataflow is able to deal with batch processing jobs, but also with streaming jobs.

Pipelines, translators and runners

Using this SDK, your jobs are actually designed as pipeline. A pipeline is a chain of processes on the data.

It’s basically the only part that you have to write.

Dataflow reads the pipelines definition, and translate them for a target runner like SPARK/FLINK. A translator is responsible of adapting the pipeline code depending of the runner. For instance, the MapReduce translator will transform pipelines as MapReduce jobs, the Spark translator will transform pipelines as Spark jobs, etc.

The runners are the “execution” layer. Once a pipeline has been “translated” by a translator, it can be run directly on a runner. The runner “hides” the actual back end: MapReduce/Yarn cluster, Spark cluster (running on Yarn or Mesos), etc.

If Dataflow comes with ready to use translators and runners, you can create your own ones.
For instance, you can implement your own runner by creating a class extending PipelineRunner. You will have to implement different runner behaviors (like the transform evaluates, supported options, apply main transform hook method, etc).

SDK:

The SDK is composed by four parts:

Pipelines are the streaming and processing logic that you want to implement. It’s a chain of processes. Basically, in a pipeline, you read data from a source, you apply transformations on the data, and eventually send the data to a destination (named sink in Dataflow wording).

PCollection is the object transported inside a pipeline. It’s the container of the data, flowing between each step of the pipeline.

Transform is a step of a pipeline. It takes an incoming PCollection and creates an out coming PCollection. You can implement your own transform function.

Sink and Source are used to retrieve data as input (first step) of a pipeline, and eventually send the data outside of the pipeline.

Scala Overview

Scala Overview

Scala, short for Scalable language, is a functional programming language. Scala integrates features of object-oriented and functional languages and it is compiled to run on the Java Virtual Machine.

Scala is object oriented

Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes which will be explained in subsequent chapters.
Classes are extended by subclass and a flexible composition mechanism as a clean replacement for multiple inheritance.

Scala runes on JVM

Scala is compiled into Java Byte Code, which is executed by the Java Virtual Machine (JVM). This means that Scala and Java have a common run-time platform. You can easily move from Java to Scala. The Scala compiler compiles your Scala code into Java Byte Code, which can then be executed by the scala command. The scala command is similar to the java command.

Scala is functional

Scala is also a functional language in the sense that every function is a value and because every value is an object so ultimately every function is an object.
Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying.

Scala can execute java code

Scala enables you to use all the classes of the Java SDK's in Scala, and also your own, custom Java classes, or your favourite Java open source projects.

Java is statically typed

Scala, unlike some of the other statically typed languages, does not expect you to provide redundant type information. You don't have to specify a type in most cases, and you certainly don't have to repeat it.

Scala features which is differ from Java

Scala has a set of features, which differ from Java. Some of these are: 
  • All types are objects.
  • Type inference.
  • Nested Functions.
  • Functions are objects.
  • Domain specific language (DSL) support.
  • Traits.
  • Closures.
  • Concurrency support inspired by Erlang.
Scala is being used everywhere and importantly in enterprise web applications. You can check few of the most popular Scala web frameworks:
  • The Lift Framework.
  • The Play framework.
  • The Bowler framework.

Environment Setup

The Scala language can be installed on any UNIX-like or Windows system. Before you start installing Scala on your machine, you must make sure that you have Java 1.5 or greater installed on your computer.

Installing Scala on Windows


Java Setup:

First, you must set the JAVA_HOME environment variable and add the JDK's bin directory to your PATH variable. To verify if everything is fine, at command prompt, do following.

C:\>java -version 
java version "1.7.51" 
Java(TM) SE Runtime Environment (build 1.7.51-b51) 
Java HotSpot(TM) 64-Bit Server VM (build 14.1-b05, mixed mode) 
C:\>

Test to see that the Java compiler is installed. Type javac -version. You should see something like the following:

C:\>javac -version javac 1.7.51 
C:\> 

Scala Setup:

you can download Scala from http://www.scala-lang.org/downloads. I am trying with scala-2.9.0.1-installer.jar and put it in C:/> directory. Execute the following command at command prompt:

C:\>java -jar scala-2.9.0.1-installer.jar 
C:\>

This will display an installation wizard, which will guide you to install scala on your windows machine. During installation, it will ask for license agreement, simply accept it and further it will ask a path where scala will be installed.

C:\>scala -version 
Scala code runner version 2.9.0.1 -- Copyright 2002-2011, LAMP/EPFL 
C:\>

Installing Scala on Linux


Java Setup:

Make sure you have Java JDK 1.7 or greater installed on your computer and set JAVA_HOME environment variable and add the JDK's bin directory to your PATH variable. To verify if everything is fine, at command prompt, type java -version and press Enter. You should see something like the following:

$java -version 
java version "1.7.51" 
Java(TM) 2 Runtime Environment, Standard Edition (build 1.7.51-b03) 
Java HotSpot(TM) Server VM (build 1.7.51-b03, mixed mode) 
$

Test to see that the Java compiler is installed. Type javac -version.

$javac -version 
javac 1.5.0_22 
javac: no source files 
Usage: javac <options> <source files> 
................................................ 
$

Scala Setup:

you can download Scala from http://www.scala-lang.org/downloads. I am trying with scala-2.9.0.1-installer.jar and put it in /tmp directory. Execute the following command at command prompt:

$java -jar scala-2.9.0.1-installer.jar 
Welcome to the installation of scala 2.9.0.1! 
The homepage is at: http://scala-lang.org/ 
press 1 to continue, 2 to quit, 3 to redisplay 
................................................ 
[ Starting to unpack ] 
[ Processing package: Software Package Installation (1/1) ] 
[ Unpacking finished ] 
[ Console installation done ] 
$

This will display an installation wizard, which will guide you to install scala on your windows machine. During installation, it will ask for license agreement, simply accept it and further it will ask a path where scala will be installed.

$scala -version 
Scala code runner version 2.9.0.1 -- Copyright 2002-2011, LAMP/EPFL 
$

Scala basic

The biggest syntactic difference between Scala and Java is that the ; line end character is optional. When we consider a Scala program it can be defined as a collection of objects that communicate via invoking each others methods.

  • Object - Objects have states and behaviors. Example: A cat has states - color, name as well as behaviors - eating. An object is an instance of a class.
  • Class - A class can be defined as a blueprint that describes the behaviors/states that object of its type support.
  • Methods - A method is basically a behavior. A class can contain many methods. It is in methods where the logics are written, data is manipulated and all the actions are executed.
  • Fields - Each object has its unique set of instant variables, which are called fields. An object's state is created by the values assigned to these fields

Wednesday 4 January 2017

Java Coding Standards

Java Coding Standards

1.     Introduction


The intent of this document is to create a guide for software source code quality based on Java Standard. The guidelines appearing herein apply to anyone who creates, modifies or read software source code for Java.
This document is not a description of a complete software process. A particular group will need to develop their own methodologies and procedures for the specification, design, implementation, testing and deployment of their software systems. This document is simply a set of rules to follow during the implantation phase that will help produce a high quality result.

2.     What this process will achieve


You can hope to achieve three goals by requiring a consistent source code style.

  • ·        Improving the productivity of existing programmers.
  • ·        Allow new programmers to become comfortable with existing source code in less time than would otherwise be necessary.
  • ·        Allow existing programmers to move around to different projects easily without having to adjust to the programming style in use by other groups.
Standardizing the "look and feel" of the source code will reduce the time to market, it will reduce the time spent correcting problems in the product line, and it will give engineers the flexibility to jump on and off projects without a large learning curve. This means that you will be able to spend less time on legacy products and jump into the more interesting task of designing and implementing future products.

3.     Java


This Document delves into some fundamental java programming techniques and provides a rich collection of coding practices to be followed by JAVA/J2EE based application development teams for Java.
This document is written for Java software developers to help them:

  • ·        Write java code that is easy to maintain and enhance
  • ·        Increase their productivity

3.1.  Standards for Classes, Interfaces, Packages, and Compilation Units

3.1.1.  Standards for Packages

3.1.1.1.      Naming packages

The rules associated with the naming of packages as follows:
Unless required otherwise, a package name should include the organization’s domain name, with the top level domain type in lower case ASCII letters i.e. com.<Name of company> followed by project name and sub project name as specified in ISO Standard 3166, 1981.
Eg:- com.<companyname>.<modulename>.<other>
Subsequent components of the package name vary according to requirements.
Package names should preferably be singular.

                 3.1.1.2.      Documenting a Package

There should be one or more external documents in html format with the package name that describe the purpose of the packages documenting the rationale for the package, the list of classes and interfaces in the package with a brief description of each so that other developers know what the package contains.

3.1.2.  Standards for Classes

Naming Classes:
Class names should be simple full English descriptor nouns, in mixed case starting with the first letter capitalized and the first letter of each internal word also capitalized. Whole words should be used instead of acronyms and abbreviations unless the abbreviation is more widely used than the long form, such as URL or HTML.

Class Visibility:
Package or default visibility may be used for classes internal to a component while public visibility may be used for other components. However, for a good design, the rule is to be as restrictive as possible when setting the visibility. The reason why the class is public should be documented. Each class should have an appropriate constructor.


Documenting a Class:
The documentation comments for a class start with the header for class with filename, version, copyright and related information. The documentation comments should precede the definition of a class and should contain necessary information about the purpose of the class, details of any known bugs, examples etc. as illustrated in. The development/maintenance history of the class should be entered as comments in the configuration management tool at the time of baselining the source code and in the file header as well.

3.1.3.  Standards for interfaces

The Java convention is to name interfaces using mixed case with the first letter of each word capitalized like classes. The preferred convention for the name of an interface is to use a descriptive adjective, such as Runnable or Clone able. Interfaces should be documented specifying the purpose of the interface and how it should and shouldn’t be used. Method declarations in interfaces should explicitly declare the methods as public for clarity.

3.1.4.  Standards for Methods

Naming Methods:
Methods should be named using a full English description, using mixed case with the first letter of any non-initial word capitalized. It is also common practice for the first word of a method name to be a strong, active verb. e.g. getValue(), printData(), save() ,delete(). This convention results in methods whose purpose can often be determined just by looking at its name. It is recommended that accessor methods be used to improve the maintainability of classes.

Getters:
Getters are methods that return the value of a field. The word ‘get’ should be prefixed to the name of the field, unless it is a boolean field where ‘is’ should be prefixed to the name of the field.  e.g. getTotalSales(), isPersistent(). Alternately the prefix ‘has’ or ‘can’ instead of ‘is’ for boolean getters may be used. For example, getter names such as hasDependents() and canPrint() can be created. Getters should always be made protected, so that only subclasses can access the fields except when an ‘outside class’ needs to access the field when the getter method may be made public and the setter protected.


Setters:
Setters, also known as mutators, are methods that modify the values of a field. The word ‘set’ should be prefixed to the name of the field for such methods type. Example: setTotalSales(), setPersistent(boolean isPersistent)

Getters for constants:
Constant values may need to be changed over a period of time. Therefore constants should be implemented as getter methods. By using accessors for constants there is only one source to retrieve the value. This increases the maintainability of system.

Accessors for collections:
The main purpose of accessors is to encapsulate the access to fields. Collections, such as arrays and vectors need to have getter and setter method and as it is possible to add and remove to and from collections, accessor methods need to be included to do so. The advantage of this approach is that the collection is fully encapsulated, allowing changes later like replacing it with another structure, like a linked list.
Examples: getOrderItems(), setOrderItems(), insertOrderItem(), deleteOrderItem(), newOrderItem()

Method Visibility:
For a good design, the rule is to be as restrictive as possible when setting the visibility of a method. If a method doesn’t have to be private then it should have default access modifier, if it doesn’t have to be default then it should be made protected and if it doesn’t have to protect only then it should be made public. Wherever a method is made more visible it should be documented why.
Access modifier for methods should be explicitly mentioned in cases like interfaces where the default permissible access modifier is public.

Standards for Parameters (Arguments) to Methods :
Parameters should be named following the same conventions as for local variables. Parameters to a method are documented in the header documentation for the method using the javadoc@param tag.
However:
  • ·        Cascading method calls like method1().method2() should be avoided.
  • ·        Overloading methods on argument type should be avoided.
  • ·        It should be declared when a class or method is thread-safe.
  • ·        Synchronized methods should be preferred over synchronized blocks.
  • ·        The fact that a method invokes wait should always be documented.
  • ·        Abstract methods should be preferred in base classes over those with default implementations.
  • ·        All possible overflow or underflow conditions should be checked for a computation.

There should be no space between a method/constructor name and the parenthesis but there should be a blank space after commas in argument lists.

3.1.5.  Naming Convention Standards

Naming Variables:
Use a full English descriptor for variable names to make it obvious what the field represents. Fields, that are collections, such as arrays or vectors, should be given names that are plural to indicate that they represent multiple values. Variable names should not start with an underscore _ or dollar sign $ characters and should be short and meaningful. The choice of a variable name should be mnemonic i.e., designed to indicate to the casual observer the intent of its use. Single character variable names should be avoided except for temporary “throwaway” variables.

Naming Components:
For names of components, full English descriptor should be used, post fixed by the Component type. This makes it easy to identify the purpose of the component as well as its type, making it easier to find each component in a list. Therefore names like NewHelpMenuItem, CloseButton should be preferred over Button1, Button2, etc.

Naming Constants:
Constants, whose values that do not change, are typically implemented as static final fields of classes. They should be represented with full English words, all in uppercase, with underscores between the words like FINAL_VALUE.

Naming Collections:
A collection, such as an array or a vector, should be given a pluralized name representing the types of objects stored by the array. The name should be a full English descriptor with the first letter of all non-initial words capitalized like customers, orderItems, aliases.

Naming Local Variables:
In general, local variables are named following the same conventions as used for fields, in other words use of full English descriptors with the first letter of any non-initial word in uppercase. For the sake of convenience, however, this naming convention is relaxed for several specific types of local variable like Streams, Loop counters, Exceptions. Name hiding or data hiding refers to the practice of naming a local variable, argument, or methods the same or similar as that of another one of greater scope in same or super class. This may lead to confusion and should be avoided.

Naming Streams:
When there is a single input and/or output stream being opened, used, and then closed within a method the common convention is to use ‘in’ and ‘out’ for the names of these streams, respectively.

Naming Loop Counters:
Loop counters are a very common use for local variables therefore the use of i, j, or k, is acceptable for loop counters where they are obvious. However, if these names are used for loop counters, they should be used consistently. For complex nested loops the counters should be given full meaningful English descriptors.

3.1.6.  Comments on class methods

Each method should declare the javadoc tags exactly in the sequence as given below. Each line item begins with an asterisk. All subsequent lines in multiline component are to be indented so that they line up vertically with the previous line. For reference, the javadoc tags are explained in detail in Annexure.
Example:
/**
* Description:
* @param <Mandatory Tag> for description of each parameter
* @return <Mandatory Tag> except for constructor and void>
* @exception <Optional Tag>
* @see <Optional Tag>
* @since <Optional Tag>
* @deprecated <Optional Tag>
*/

3.1.7.  Best Practices:

Efficient String Concatenations
For making a long string by adding different small strings always use append method of java.lang.StringBuffer and never use ordinary ‘+’ operator for adding up strings.

Optimal use of Garbage collection
For easing out the work of java Garbage Collector always set all referenced variables used to ‘null’ explicitly thus de-referencing the object which is no more required by the application and allowing Garbage Collector to swap away that variable thus realizing memory.

Use variables in any code optimally
Try to make minimum number of variables in JSP/Java class and try to use already made variables in different algorithms shared in same JSP/Java class by setting already populated variable to ‘null’ and then again populating that variable with new value and then reusing them.

Try to reduce the number of hits to database
Number of hits to the database should be reduced to minimum by getting data in a well arranged pattern in minimum number of hits by making the best use of joins in the database query itself rather than getting dispersed data in more number of hits.

Heavy Object should not be stored in sessions
Storing heavy objects in the Session can lead to slowing of the running of the JSP page so such case should be avoided.

Always use database connection pooling
Always use javax.sql.DataSource which is obtained through a JNDI naming lookup. Avoid the overhead of acquiring a javax.sql.DataSource for each SQL access. This is an expensive operation that will severely impact the performance and scalability of the application.

Release database resources when done
Failing to close and release JDBC connections can cause other users to experience long waits for connections. Although a JDBC connection that is left unclosed will be reaped and returned by Application Server after a timeout period, others may have to wait for this to occur. Close JDBC statements when you are through with them. JDBC ResultSets can be explicitly closed as well. If not explicitly closed, ResultsSets are released when their associated statements are closed. Ensure that your code is structured to close and release JDBC resources in all cases, even in exception and error conditions.

Minimum use of System.out.println
Because it seems harmless, this commonly used application development legacy is overlooked for the performance problem it really is. Because System.out.println statements and similar constructs synchronize processing for the duration of disk I/O,they can significantly slow throughput.

Synchronization has a cost

  • ·        Putting synchronized all over the place does not ensure thread safety.
  • ·        Putting synchronized all over the place is likely to deadlock.
  • ·        Putting synchronized all over will slow your code and prevent it from running when it should. This accounts for memory leaks.

3.1.8.  Technical points

Apart from the standards mentioned already following should be considered while writing java

  • ·        Instance /class variables should not be made public as far as possible.
  • ·        A constructor or method must explicitly declare all unchecked (i.e. runtime) exceptions it expects to throw. The caller can use this documentation to provide the proper arguments.
  • ·        Unchecked exceptions should not be used instead of code that checks for an exceptional condition. e.g. Comparing an index with the length of an array is faster to execute and better documented than catching arrayOutOfBoundsException.
  • ·        If Object.equals is overridden, also override Object.hashCode, and vice-versa.
  • ·        Override readObject and writeObject if a Serializable class relies on any state that could differ across processes,including,in particular,hashCodes and transient fields.
  • ·        If clone() may be called in a class, then it should be explicitly defined, and declare the class as implements Cloneable.
  • ·        Always use method equals instead of operator == when comparing objects. In particular, do not use == to compare Strings unless comparing memory locations.
  • ·        Always embed wait statements in while loops that re-wait if the condition being waited for does not hold.
  • ·        Use notifyAll instead of notify or resume when you do not know exactly the number of threads which are waiting for something
  • ·        When throwing an exception, do not refer to the name of the method which has thrown it but specify instead some explanatory text.
  • ·        Document fragile constructions that have been used solely for the sake of optimization.
  • ·        Document cases where the return value of a called method is ignored.
  • ·        Minimize * forms of import Be precise about what you are importing.
  • ·        Prefer declaring arrays as Type[] arrayName rather than Type arrayName[].
  • ·        StringBuffer should be preferred for cases involving String concatenations. Wherever required String objects should be preferably created with a new and not with the help of assignment, unless intentionally as they remain in the String pool even after reference is nullified.
  • ·        All class variables must be initialized with null at the point of declaration.
  • ·        All references to objects should be explicitly assigned ‘null’ when no more in use to make the objects available for garbage collection.
  • ·        As far as possible static or class fields should be explicitly instantiated by use of static initializers because instances of a class may sometimes not be created before a static field is accessed.
  • ·        Minimize statics (except for static final constants).
  • ·        Minimize direct internal access to instance variables inside methods.
  • ·        Declare all public methods as synchronized.
  • ·        Always document the fact that a method invokes wait.
  • ·        Classes designed should be easily extensible. This will be very important in the event that the currently designed project needs to be enhanced at a later stage.
  • ·        It is very important to have the finally clause (whenever required) because its absence can cause memory leakage and open connections in a software.


 Thanks



Thursday 3 November 2016

How to configure Redmine for advanced integration with Subversion

How to configure Redmine for advanced integration with Subversion

Before starting this guide, take into account that this is not necessary to see the repository changes in the Redmine application. If you only want to see the repository changes and link to the issues, it is only necessary to configure the project repository: Project -> Settings -> Repository -> URL and Control Version System.

This Redmine configuration is for automatic repository creation and rights management. Since 1.1.3-1 version, Redmine Stack ships all required modules for this configuration. Notice that if you are using Virtual Appliances or AMIs the installdir variable is "/opt/bitnami". It could be necessary to use the "sudo" command if the Stack was installed by the root user.

This guide has been updated to work with Redmine 3+.

    Add the following lines in Apache configuration file (httpd.conf):

~~~
LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule perl_module modules/mod_perl.so
~~~

Copy the Redmine.pm file into the Perl modules folder:

$ cp /installdir/apps/redmine/htdocs/extra/svn/Redmine.pm installdir/perl/lib/site_perl/5.8.8/*/Apache2/

Create a folder for the repository, for instance:

$ mkdir /installdir/repository
$ mkdir /installdir/repository/svn
$ chown root:daemon installdir/repository/ [or "your_user:your_user" if you installed the Stack without root privileges]
$ chown root:daemon installdir/repository/svn/ [or "your_user:your_user" if you installed the Stack without root privileges]
$ chmod 0755 /installdir/repository
$ chmod 0750 /installdir/repository/svn


Add to the @installdir/apps/redmine/conf/httpd-app.conf@ file.

`PerlLoadModule Apache2::Redmine
<Location /svn>
  DAV svn
  SVNParentPath "/installdir/repository/svn" 
  Order deny,allow
  Deny from all
  Satisfy any

  PerlAccessHandler Apache::Authn::Redmine::access_handler
  PerlAuthenHandler Apache::Authn::Redmine::authen_handler
  AuthType Basic
  AuthName "Redmine SVN Repository" 

  #read-only access   
  <Limit GET PROPFIND OPTIONS REPORT>
     Require valid-user 
     Allow from localhost
     Allow from 192.168.1.9
     Satisfy any
  </Limit>
  # write access
  <LimitExcept GET PROPFIND OPTIONS REPORT>
    Require valid-user
  </LimitExcept>

  ## for mysql
  RedmineDSN "DBI:mysql:database=bitnami_redmine;host=localhost;mysql_socket=/installdir/mysql/tmp/mysql.sock" 

  RedmineDbUser "bitnami" 
  RedmineDbPass "bitnami_database_password"    
  #You can find this value at /installdir/apps/redmine/htdocs/config/database.yml
</Location>`


Restart the servers:

$ /installdir/ctlscript.sh restart

    Log in the Redmine application as Administrator and go to "Settings" -> "Repositories" -> "Enable WS for repository management".
    Click on "Generate a key" and save it.
    Add the following line in the crontab. You can edit the crontab using the command "crontab -e"

*/2 * * * * /installdir/ruby/bin/ruby /installdir/apps/redmine/htdocs/extra/svn/reposman.rb --redmine localhost:YOUR_APACHE_PORT/redmine --svn-dir /installdir/repository/svn --owner root --group daemon --command="/installdir/subversion/bin/svnadmin create --pre-1.6-compatible --fs-type fsfs" --url http://YOUR_PUBLIC_IP_ADDRESS:YOUR_APACHE_PORT/svn --key="YOUR_API_KEY" --verbose >> /var/log/reposman.log 


    If you have configured Redmine to accress through SSL, you can specify "--redmine @http://127.0.0.1:3001/redmine@" in the previous crontab line.
    You can check that everything works properly creating a project from the Redmine application and checking the /var/log/reposman.log file.

Permission and ownership setting

create folders for svn repository

*<installdir>/repository*
*<installdir>/repository/svn*

cd *<installdir>/repository/svn*

svnadmin create <repodirname>


From *<installdir>*

chown -R nobody:apache repository/
chmod -R 777 repository/svn/


Wednesday 2 November 2016

UNIX Tutorial for Beginners

UNIX Tutorial for Beginner

Here you go with the tutorial.

1. Introduction to the UNIX operating system

a.   What is UNIX?

UNIX is an operating system which was first developed in the 1960s, and has been under constant development ever since. By operating system, we mean the suite of programs which make the computer work. It is a stable, multi-user, multi-tasking system for servers, desktops and laptops.
UNIX systems also have a graphical user interface (GUI) similar to Microsoft Windows which provides an easy to use environment. However, knowledge of UNIX is required for operations which aren't covered by a graphical program, or for when there is no windows interface available, for example, in a telnet session.

b.  Files and Processes

Everything in UNIX is either a file or a process.
A process is an executing program identified by a unique PID (process identifier).
A file is a collection of data. They are created by users using text editors, running compilers etc.
Examples of files:
·         a document (report, essay etc.)
·         the text of a program written in some high-level programming language
·         instructions comprehensible directly to the machine and incomprehensible to a casual user, for example, a collection of binary digits (an executable or binary file);
·         a directory, containing information about its contents, which may be a mixture of other directories (subdirectories) and ordinary files.

c.   The Directory Structure

All the files are grouped together in the directory structure. The file-system is arranged in a hierarchical structure, like an inverted tree. The top of the hierarchy is traditionally called root (written as a slash / )
In the diagram above, we see that the home directory of the undergraduate student "ee51vn" contains two sub-directories (docs and pics) and a file called report.doc.
The full path to the file report.doc is "/home/its/ug1/ee51vn/report.doc"

2. Section One

a.   Listing files and directories

ls (list)
When you first login, your current working directory is your home directory. Your home directory has the same name as your user-name, for example, ee91ab, and it is where your personal files and subdirectories are saved.
To find out what is in your home directory, type
% ls
The ls command (lowercase L and lowercase S) lists the contents of your current working directory.

There may be no files visible in your home directory, in which case, the UNIX prompt will be returned. Alternatively, there may already be some files inserted by the System Administrator when your account was created.
ls does not, in fact, cause all the files in your home directory to be listed, but only those ones whose name does not begin with a dot (.) Files beginning with a dot (.) are known as hidden files and usually contain important program configuration information. They are hidden because you should not change them unless you are very familiar with UNIX!!!
To list all files in your home directory including those whose names begin with a dot, type
% ls -a
As you can see, ls -a lists files that are normally hidden.
ls is an example of a command which can take options: -a is an example of an option. The options change the behavior of the command.

b.  Making Directories

mkdir (make directory)
We will now make a subdirectory in your home directory to hold the files you will be creating and using in the course of this tutorial. To make a subdirectory called Unix stuff in your current working directory type
% mkdir unixfolder
To see the directory you have just created, type
% ls

c.   Changing to a different Directory

cd (change directory)
The command cd directory means change the current working directory to 'directory'. The current working directory may be thought of as the directory you are in, i.e. your current position in the file-system tree.
To change to the directory you have just made, type
% cd unixfolder
Type ls to see the contents (which should be empty)
Exercise 1a
Make another directory inside the unixfolder directory called backups

d.  The directories. and..

Still in the unixfolder directory, type
% ls -a
As you can see, in the unixfolder directory (and in all other directories), there are two special directories called (.) and (..)
The current directory (.)
In UNIX, (.) means the current directory, so typing
% cd .
NOTE: there is a space between cd and the dot
means stay where you are (the unixfolder directory).
This may not seem very useful at first, but using (.) as the name of the current directory will save a lot of typing, as we shall see later in the tutorial.
The parent directory (..)
(..) Means the parent of the current directory, so typing
% cd ..
will take you one directory up the hierarchy (back to your home directory). Try it now.
Note: typing cd with no argument always returns you to your home directory. This is very useful if you are lost in the file system.

e.   Pathnames

pwd (print working directory)
Pathnames enable you to work out where you are in relation to the whole file-system. For example, to find out the absolute pathname of your home-directory, type cd to get back to your home-directory and then type
% pwd
The full pathname will look something like this -
/home/its/ug1/ee51vn
which means that ee51vn (your home directory) is in the sub-directory ug1 (the group directory),which in turn is located in the its sub-directory, which is in the home sub-directory, which is in the top-level root directory called " / " .

Exercise 1b
Use the commands cd, ls and pwd to explore the file system.
(Remember, if you get lost, type cd by itself to return to your home-directory)

f.    More about home directories and pathnames

Understanding pathnames
First type cd to get back to your home-directory, then type
% ls unixfolder
to list the contents of your unixfolder directory.
Now type
% ls backups
You will get a message like this -
backups: No such file or directory
The reason is, folder backups is not in your current working directory. To use a command on a file (or directory) not in the current working directory (the directory you are currently in), you must either cd to the correct directory, or specify its full pathname. To list the contents of your backups directory, you must type
% ls unixfolder/backups

~ (your home directory)
Home directories can also be referred to by the tilde ~ character. It can be used to specify paths starting at your home directory. So typing
% ls ~/unixfolder
will list the contents of your unixfolder directory, no matter where you currently are in the file system.
Exercise:
% ls ~
Would list?
% ls ~/..
Would list?

Summary
Command
Meaning
ls
list files and directories
ls –a
list all files and directories
mkdir
make a directory
cd directory
change to named directory
cd
change to home-directory
cd ~
change to home-directory
cd ..
change to parent directory
pwd
display the path of the current directory

3. Section Two

a.   Copying Files

cp (copy)
cp file1 file2 is the command which makes a copy of file1 in the current working directory and calls it file2
What we are going to do now, is to take a file stored in an open access area of the file system, and use the cp command to copy it to your unixfolder directory.
First, cd to your unixfolder directory.
% cd ~/unixfolder
Then at the UNIX prompt, type,
% cp /vol/examples/tutorial/science.txt .
Note: Don't forget the dot . at the end. Remember, in UNIX, the dot means the current directory.
The above command means copy the file science.txt to the current directory, keeping the name the same.
(Note: The directory /vol/examples/tutorial/ is an area to which everyone in the school has read and copy access. If you are from outside the University, you can grab a copy of the file here. Use 'File/Save As..' from the menu bar to save it into your unixfolder directory.)
Exercise 2a
Create a backup of your science.txt file by copying it to a file called science.bak

b.  Moving Files

mv (move)
mv file1 file2 moves (or renames) file1 to file2
To move a file from one place to another, use the mv command. This has the effect of moving rather than copying the file, so you end up with only one file rather than two.
It can also be used to rename a file, by moving the file to the same directory, but giving it a different name.
We are now going to move the file science.bak to your backup directory.
First, change directories to your unixfolder directory (can you remember how?). Then, inside the unixfolder directory, type
% mv science.bak backups/.
Type ls and ls backups to see if it has worked.

c.   Removing Files and directories

rm (remove), rmdir (remove directory)
To delete (remove) a file, use the rm command. As an example, we are going to create a copy of the science.txt file then delete it.
Inside your unixfolder directory, type
% cp science.txt tempfile.txt
% ls
% rm tempfile.txt
% ls
You can use the rmdir command to remove a directory (make sure it is empty first). Try to remove the backups directory. You will not be able to since UNIX will not let you remove a non-empty directory.
Exercise 2b
Create a directory called tempfolder using mkdir , then remove it using the rmdir command.




d.  Displaying the contents of a file on the screen

clear (clear screen)
Before you start the next section, you may like to clear the terminal window of the previous commands so the output of the following commands can be clearly understood.
At the prompt, type
% clear
This will clear all text and leave you with the % prompt at the top of the window.

cat (concatenate)
The command cat can be used to display the contents of a file on the screen. Type:
% cat science.txt
As you can see, the file is longer than the size of the window, so it scrolls past making it unreadable.

less
The command less writes the contents of a file onto the screen a page at a time. Type
% less science.txt
Press the [space-bar] if you want to see another page, and type [q] if you want to quit reading. As you can see, less is used in preference to cat for long files.

head
The head command writes the first ten lines of a file to the screen.
First clear the screen then type
% head science.txt
Then type
% head -5 science.txt
What difference did the -5, to the head command?

tail
The tail command writes the last ten lines of a file to the screen.
Clear the screen and type
% tail science.txt

e.   Searching the contents of a file

Simple searching using less
Using less, you can search though a text file for a keyword (pattern). For example, to search through science.txt for the word 'science', type
% less science.txt
then, still in less, type a forward slash [/] followed by the word to search
/science
As you can see, less finds and highlights the keyword. Type [n] to search for the next occurrence of the word.

grep (please don't ask why it is called grep)
grep is one of many standard UNIX utilities. It searches files for specified words or patterns. First clear the screen, then type
% grep science science.txt
As you can see, grep has printed out each line contains the word science.
Or has it????
Try typing
% grep Science science.txt
The grep command is case sensitive; it distinguishes between Science and science.
To ignore upper/lower case distinctions, use the -i option, i.e. type
% grep -i science science.txt
To search for a phrase or pattern, you must enclose it in single quotes (the apostrophe symbol). For example to search for spinning top, type
% grep -i 'spinning top' science.txt
Some of the other options of grep are:
-v displays those lines that do NOT match
-n precede each matching line with the line number
-c prints only the total count of matched lines
Try some of them and see the different results. Don't forget, you can use more than one option at a time. For example, the number of lines without the words science or Science is
% grep -ivc science science.txt

wc (word count)
A handy little utility is the wc command, short for word count. To do a word count on science.txt, type
% wc -w science.txt
To find out how many lines the file has, type
% wc -l science.txt

 

Command
Meaning
cp file1 file2
copy file1 and call it file2
mv file1 file2
move or rename file1 to file2
rm file
remove a file
rmdir directory
remove a directory
cat file
display a file
less file
display a file a page at a time
head file
display the first few lines of a file
tail file
display the last few lines of a file
grep 'keyword' file
search a file for keywords
wc file
count number of lines/words/characters in file

4. Section Three

a.   Redirection

Most processes initiated by UNIX commands write to the standard output (that is, they write to the terminal screen), and many take their input from the standard input (that is, they read it from the keyboard). There is also the standard error, where processes write their error messages, by default, to the terminal screen.
We have already seen one use of the cat command to write the contents of a file to the screen.
Now type cat without specifying a file to read
% cat
Then type a few words on the keyboard and press the [Return] key.
Finally hold the [Ctrl] key down and press [d] (written as ^D for short) to end the input.
What has happened?
If you run the cat command without specifying a file to read, it reads the standard input (the keyboard), and on receiving the 'end of file' (^D), copies it to the standard output (the screen).
In UNIX, we can redirect both the input and the output of commands.

b.  Redirecting the Output

We use the > symbol to redirect the output of a command. For example, to create a file called list1 containing a list of fruit, type 
% cat > list1
Then type in the names of some fruit. Press [Return] after each one.
mango
banana
apple
^D {this means press [Ctrl] and [d] to stop}
What happens is the cat command reads the standard input (the keyboard) and the > redirects the output, which normally goes to the screen, into a file called list1
To read the contents of the file, type
% cat list1
Exercise 3a
Using the above method, create another file called list2 containing the following fruit: orange, plum and mango. Read the contents of list2

Appending to a file
The form >> appends standard output to a file. So to add more items to the file list1, type
% cat >> list1
Then type in the names of more fruit
mango
apple
orange
^D (Control D to stop)

To read the contents of the file, type
% cat list1
You should now have two files. One contains six fruit, the other contains four fruit.
We will now use the cat command to join (concatenate) list1 and list2 into a new file called biglist. Type
% cat list1 list2 > biglist
What this is doing is reading the contents of list1 and list2 in turn, then outputing the text to the file biglist
To read the contents of the new file, type
% cat biglist

c.   Redirecting the Input

We use the < symbol to redirect the input of a command.
The command sort alphabetically or numerically sorts a list. Type
% sort
Then type in the names of some animals. Press [Return] after each one.
dog
cat
bird
ape
^D (control d to stop)
The output will be
ape
bird
cat
dog
Using < you can redirect the input to come from a file rather than the keyboard. For example, to sort the list of fruit, type
% sort < biglist
and the sorted list will be output to the screen.
To output the sorted list to a file, type,
% sort < biglist > slist
Use cat to read the contents of the file slist

d.  Pipes

To see who is on the system with you, type
% who
One method to get a sorted list of names is to type,
% who > names.txt
% sort < names.txt
This is a bit slow and you have to remember to remove the temporary file called names when you have finished. What you really want to do is connect the output of the who command directly to the input of the sort command. This is exactly what pipes do. The symbol for a pipe is the vertical bar |
For example, typing
% who | sort
will give the same result as above, but quicker and cleaner.
To find out how many users are logged on, type
% who | wc –l




Command
Meaning
command > file
redirect standard output to a file
command >> file
append standard output to a file
command < file
redirect standard input from a file
command1 | command2
pipe the output of command1 to the input of command2
cat file1 file2 > file0
concatenate file1 and file2 to file0
sort
sort data
who
list users currently logged in

5. Section Four

a.   Wildcards

The * wildcard
The character * is called a wildcard, and will match against none or more character(s) in a file (or directory) name. For example, in your unixfolder directory, type
% ls list*
This will list all files in the current directory starting with list....
Try typing
% ls *list
This will list all files in the current directory ending with ....list
The ? wildcard
The character ? will match exactly one character.
So ?ouse will match files like house and mouse, but not grouse.
Try typing
% ls ?list

b.  Filename Conventions

We should note here that a directory is merely a special type of file. So the rules and conventions for naming files apply also to directories.
In naming files, characters with special meanings such as / * & % , should be avoided. Also, avoid using spaces within names. The safest way to name a file is to use only alphanumeric characters, that is, letters and numbers, together with _ (underscore) and . (dot).
Good filenames
Bad filenames
project.txt
project
my_big_program.c
my big program.c
fred_dave.doc
fred & dave.doc

File names conventionally start with a lower-case letter, and may end with a dot followed by a group of letters indicating the contents of the file. For example, all files consisting of C code may be named with the ending .c, for example, prog1.c . Then in order to list all files containing C code in your home directory, you need only type ls *.c in that directory.

c.   Getting Help

On-line Manuals
There are on-line manuals which gives information about most commands. The manual pages tell you which options a particular command can take, and how each option modifies the behavior of the command. Type man command to read the manual page for a particular command.
For example, to find out more about the wc (word count) command, type
% man wc
Alternatively
% whatis wc
gives a one-line description of the command, but omits any information about options etc.


Apropos
When you are not sure of the exact name of a command,
% apropos keyword
will give you the commands with keyword in their manual page header. For example, try typing
% apropos copy
Command
Meaning
*
match any number of characters
?
match one character
man command
read the online manual page for a command
whatis command
brief description of a command
apropos keyword
match commands with keyword in their man pages

6. Section Five

a.   File system security (access rights)

In your unixfolder directory, type
% ls -l (l for long listing!)
You will see that you now get lots of details about the contents of your directory, similar to the example below.


Each file (and directory) has associated access rights, which may be found by typing ls -l. Also, ls -lg gives additional information as to which group owns the file (beng95 in the following example):
-rwxrw-r-- 1 ee51ab beng95 2450 Sept29 11:52 file1
In the left-hand column is a 10 symbol string consisting of the symbols d, r, w, x, -, and, occasionally, s or S. If d is present, it will be at the left hand end of the string, and indicates a directory: otherwise - will be the starting symbol of the string.
The 9 remaining symbols indicate the permissions, or access rights, and are taken as three groups of 3.
·         The left group of 3 gives the file permissions for the user that owns the file (or directory) (ee51ab in the above example);
·         the middle group gives the permissions for the group of people to whom the file (or directory) belongs (eebeng95 in the above example);
·         the rightmost group gives the permissions for all others.
The symbols r, w, etc., have slightly different meanings depending on whether they refer to a simple file or to a directory.
Access rights on files.
·         r (or -), indicates read permission (or otherwise), that is, the presence or absence of permission to read and copy the file
·         w (or -), indicates write permission (or otherwise), that is, the permission (or otherwise) to change a file
·         x (or -), indicates execution permission (or otherwise), that is, the permission to execute a file, where appropriate
Access rights on directories.
·          r allows users to list files in the directory;
·          w means that users may delete files from the directory or move files into it;
·          x means the right to access files in the directory. This implies that you may read files in the directory provided you have read permission on the individual files.
So, in order to read a file, you must have executed permission on the directory containing that file, and hence on any directory containing that directory as a subdirectory, and so on, up the tree.
Some examples
-rwxrwxrwx
a file that everyone can read, write and execute (and delete).
-rw-------
a file that only the owner can read and write - no-one else
can read or write and no-one has execution rights (e.g. your
mailbox file).




 

b.  Changing access rights

chmod (changing a file mode)
Only the owner of a file can use chmod to change the permissions of a file. The options of chmod are as follows
Symbol
Meaning
u
user
g
group
o
other
a
all
r
read
w
write (and delete)
x
execute (and access directory)
+
add permission
-
take away permission

For example, to remove read write and execute permissions on the file biglist for the group and others, type
% chmod go-rwx biglist
This will leave the other permissions unaffected.
To give read and write permissions on the file biglist to all,
% chmod a+rw biglist

 

c.   Killing a process

kill (terminate or signal a process)
It is sometimes necessary to kill a process (for example, when an executing program is in an infinite loop)
To kill a job running in the foreground, type ^C (control c). For example, run
% sleep 100
^C
To kill a suspended or background process, type
% kill %jobnumber
For example, run
% sleep 100 &
% jobs
If it is job number 4, type
% kill %4
To check whether this has worked, examine the job list again to see if the process has been removed.
ps (process status)
Alternatively, processes can be killed by finding their process numbers (PIDs) and using kill PID_number
% sleep 1000 &
% ps
PID TT S TIME COMMAND
20077 pts/5 S 0:05 sleep 1000
21563 pts/5 T 0:00 netscape
21873 pts/5 S 0:25 nedit
To kill off the process sleep 1000, type
% kill 20077
and then type ps again to see if it has been removed from the list.
If a process refuses to be killed, uses the -9 option, i.e. type
% kill -9 20077
Note: It is not possible to kill off other users' processes!!!

Command
Meaning
ls -lag
list access rights for all files
chmod [options] file
change access rights for named file
command &
run command in background
^C
kill the job running in the foreground
^Z
suspend the job running in the foreground
bg
background the suspended job
jobs
list current jobs
fg %1
foreground job number 1
kill %1
kill job number 1
ps
list current processes
kill 26152
kill process number 26152

7. Section Six

a.   Other Useful UNIX commands

df
The df command reports on the space left on the file system. For example, to find out how much space is left on the fileserver, type
% df .

du
The du command outputs the number of kilobytes used by each subdirectory. Useful if you have gone over quota and you want to find out which directory has the most files. In your home-directory, type
% du -s *
The -s flag will display only a summary (total size) and the * means all files and directories.

gzip
This reduces the size of a file, thus freeing valuable disk space. For example, type
% ls -l science.txt
and note the size of the file using ls -l . Then to compress science.txt, type
% gzip science.txt
This will compress the file and place it in a file called science.txt.gz
To see the change in size, type ls -l again.
To expand the file, use the gunzip command.
% gunzip science.txt.gz

zcat
zcat will read gzipped files without needing to uncompressing them first.
% zcat science.txt.gz
If the text scrolls too fast for you, pipe the output though less .
% zcat science.txt.gz | less

file
file classifies the named files according to the type of data they contain, for example ascii (text), pictures, compressed data, etc.. To report on all files in your home directory, type
% file *

diff
This command compares the contents of two files and displays the differences. Suppose you have a file called file1 and you edit some part of it and save it as file2. To see the differences type
% diff file1 file2
Lines beginning with a < denotes file1, while lines beginning with a > denotes file2.

find
This search through the directories for files and directories with a given name, date, size, or any other attribute you care to specify. It is a simple command but with many options - you can read the manual by typing man find.
To search for all files with the extention .txt, starting at the current directory (.) and working through all sub-directories, then printing the name of the file to the screen, type
% find . -name "*.txt" -print
To find files over 1Mb in size, and display the result as a long listing, type
% find . -size +1M -ls

history
The C shell keeps an ordered list of all the commands that you have entered. Each command is given a number according to the order it was entered.
% history (show command history list)
If you are using the C shell, you can use the exclamation character (!) to recall commands easily.
% !! (recall last command)
% !-3 (recall third most recent command)
% !5 (recall 5th command in list)
% !grep (recall last command starting with grep)
You can increase the size of the history buffer by typing
% set history=100