Kibo world

DCS-950G streaming in Linux

2011-04-25T07:07:00.000-07:00

Yesterday I got IPcam DCS-950G. I wanted to connect camera to Motion but it did not get stream. I had to use stupid IE only. I was angry and looking for solution. I found people just as disappointed as I am. I decided to solve this problem.

I went to D-Link and study specification. After that I downgrade camera to DCS-950G_ A1_Firmware_v1.00 because the camera with this old firmware does not need admin authentication for streaming. It's so convenient. I do not have to send with each request the password.

I wanted to write a Groovy script, but I wanted to control the camera from the router, which I do not have Java. That's why I chose Bash.

After hours of testing, I had written a working script:

#!/bin/bash
#

WEBCAM_IP="192.168.0.20"

#######################################################################

#init
{ exec 3<>/dev/tcp/${WEBCAM_IP}/5000; echo -n "ARAGORN_INIT" >&3; cat <&3> /dev/null; } &

sleep 2

#start
exec 3<>/dev/tcp/${WEBCAM_IP}/5001
echo -n "ARAGORN_START#255055293901165#0#1#0" >&3

#data
while :
do
 
    head -c 40 <&3 > header.hex
    BYTES=( `hexdump -v -s 24 -n 4 -e ' 1/1 "%02X " ' header.hex` )      
    HEX="${BYTES[3]}${BYTES[2]}${BYTES[1]}${BYTES[0]}"   
    DATA_LENGTH=`echo "obase=10; ibase=16; ${HEX}" | bc`  
    head -v -c "${DATA_LENGTH}" <&3
                                
done

With MPlayer I can play the stream directly from the camera. Mplayer takes around 5% CPU on a single camera.

./dcs-950G.bash | mplayer - -demuxer mpeg4es

With ffmpeg I got every second actual jpeg for Motion.

Google Web Toolkit RPC

2010-09-05T11:26:00.000-07:00

Google Web Toolkit

GWT Java-to-JavaScript Compiler
JRE emulation library
GWT web UI
Development tools (Hosted web browser, shell,..)
RPC

Communicating with the server

RPC
XML
JSON

Packages

Making GWT Remote Procedure Calls

Modul

UI

package cz.kibo.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.ServiceDefTarget;
import com.google.gwt.user.client.ui.TextBox;

public class SayHelloEntryPoint implements EntryPoint {

    private TextBox name = new TextBox();  
    private Label response = new Label();
    private Button button = new Button("Send");

    private HelloServiceAsync service;
    private AsyncCallback serviceCallback = new AsyncCallback() {
           public void onSuccess(Object result) {
              String string = (String) result;               
              response.setText(string);
           }

           public void onFailure(Throwable caught) {
               response.setText("There was an error: " + caught.toString());
           }
    };

    /**
    * Creates a new instance of MainEntryPoint
    */
    public SayHelloEntryPoint() {
    }

    /**
    * The entry point method, called automatically by loading a module
    * that declares an implementing class as an entry-point
    */
    public void onModuleLoad() {
     
       //Obtain Async service for interface
       service = GWT.create(HelloService.class);

       //go to URL
       //or use @RemoteServiceRelativePath("hello")
       ServiceDefTarget endpoint = (ServiceDefTarget) service;
       endpoint.setServiceEntryPoint(GWT.getModuleBaseURL() + "hello");


       RootPanel root = RootPanel.get("content");       
       root.add(new Label("Name"));
       root.add(name);     

       // Listen for mouse events on the Add button.
       button.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                   service.sayHello(new Person(name.getText()), serviceCallback);
             }
       });

       root.add(button);
       root.add(response);

    }
}

Service

extends RemoteService

package cz.kibo.client;

import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

//@RemoteServiceRelativePath("hello")
public interface HelloService extends RemoteService
{
    String sayHello(Person p);

}

AsyncService

return void
have last param AsyncCallback

package cz.kibo.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface HelloServiceAsync {
    void sayHello(Person p, AsyncCallback callback);
}

Service implementation

can extends RemoteServiceServlet
or you have to implements HelloServlet yet

package cz.kibo.server;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import cz.kibo.client.HelloService;
import cz.kibo.client.Person;

public class HelloServiceImpl extends RemoteServiceServlet implements HelloService{

    public String sayHello(Person p) {
       return "Hello " + p.name;
    }
}

RemoteServiceServlet

getThreadLocalRequest()
getThreadLocalResponse()
onBeforeRequestDeserialized (String)
onAfterResponseSerialized (String)
shouldCompressResponse (HttpServletRequest, HttpServletResponse, String)
processCall(String)

Model

implements Serializable or IsSerializable

package cz.kibo.client;

import java.io.Serializable;

public class Person implements Serializable{

    public String name;
  
    public Person(){
              this(null);
    }

    public Person(String name) {
          super();
          this.name = name;      
    }
}

Netbeans project

source

XSLT

2010-08-18T02:05:00.000-07:00

Text are from http://www.w3schools.com/xsl/

XSL stands for EXtensible Stylesheet Language.
CSS - Style Sheet for HTML
XSL - Style Sheet fot XML
XSL describes how the XML document should be displayed!

XSL consists of three parts:

XSLT - a language for transforming XML documents
XPath - a language for navigating in XML documents
XSL-FO - a language for formatting XML documents

XSLT

XSLT stands for XSL Transformations
XSLT is the most important part of XSL
XSLT transforms an XML document into another XML document
XSLT uses XPath to navigate in XML documents
All major browsers have support for XML and XSLT.

XSLT - Transformation

Declaration
The root element that declares the document to be an XSL style sheet is <xsl:stylesheet> or <xsl:transform>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
or
<xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

example transformation
Source xml file.

Source XSL Style Sheet file.

Result of transformation.

<xsl:template>

The <xsl:template> element is used to build templates.

The match attribute is used to associate a template with an XML element. The match attribute can also be used to define a template for the entire XML document. The value of the match attribute is an XPath expression (i.e. match="/" defines the whole document).

example:

<xsl:value-of>

The <xsl:value-of> element can be used to extract the value of an XML element and add it to the output stream of the transformation:

<xsl:for-each>

The XSL <xsl:for-each> element can be used to select every XML element of a specified node-set:

Filtering

We can also filter the output from the XML file by adding a criterion to the select attribute in the <xsl:for-each> element.

<xsl:sort>

The <xsl:sort> element is used to sort the output.

<xsl:if>

The <xsl:if> element is used to put a conditional test against the content of the XML file.

<xsl:choose>

The <xsl:choose> element is used in conjunction with <xsl:when> and <xsl:otherwise> to express multiple conditional tests.

<xsl:apply-templates>

The <xsl:apply-templates> element applies a template to the current element or to the current element's child nodes.
If we add a select attribute to the <xsl:apply-templates> element it will process only the child element that matches the value of the attribute. We can use the select attribute to specify the order in which the child nodes are processed.

Grails: Unit testing

2010-08-06T08:08:00.000-07:00

Source:

The core of the testing plugin is the grails.test.GrailsUnitTestCase class.

mockDomain(class, testInstances)

Takes a class and makes mock implementations of all the domain class methods.

example:

void testSomething() {
  def testInstances=[]
  mockDomain(Song, testInstances)
  assertEquals(0, Song.count())
  new Song(name:"Supper's Ready").save()
  assertEquals(1, Song.count())
}

example:

def testInstances = [ new Item(code: "NH-4273997", name: "Laptop"),
                new Item(code: "EC-4395734", name: "Lamp"),
                new Item(code: "TF-4927324", name: "Laptop") ]
mockDomain(Item, testInstances)

mockForConstraintsTests(class, testInstances)

Highly specialised mocking for domain classes and command objects that allows you to check whether the constraints are behaving as you expect them to.

example:

class Book {
  String title
  String author
    static constraints = {
        title(blank: false, unique: true)
        author(blank: false, minSize: 5)
    }
}

class BookTests extends GrailsUnitTestCase {
  void testConstraints() {
      def existingBook = new Book(title: "Misery", author: "Stephen King")
      mockForConstraintsTests(Book, [ existingBook ])
        // Validation should fail if both properties are null.
        def book = new Book()
        assertFalse book.validate()
        assertEquals "nullable", book.errors["title"]
        assertEquals "nullable", book.errors["author"]
        // So let's demonstrate the unique and minSize constraints.
        book = new Book(title: "Misery", author: "JK")
        assertFalse book.validate()
        assertEquals "unique",     book.errors["title"]
        assertEquals "minSize", book.errors["author"]
        // Validation should pass!
        book = new Book(title: "The Shining", author: "Stephen King")
        assertTrue book.validate()
    }
}

mockFor(class)

This range determines how many times you expect the method to be called, so if the number of invocations falls outside of that range then an assertion error will be thrown. If no range is specified, a default of "1..1" is assumed.

The closure arguments should match the number and types of the mocked method, but otherwise you are free to add whatever you want in the body.

example:

def strictControl = mockFor(MyService)
strictControl.demand.someMethod(0..2) { String arg1, int arg2 -> … }
strictControl.demand.static.aStaticMethod {-> … }

example:

class MyService { def otherService
    String createSomething() {        
        def stringId = otherService.newIdentifier()        
        def item = new Item(code: stringId, name: "Bangle")        
        item.save()        
        return stringId      
   }
   
   int countItems(String name) {        
        def items = Item.findAllByName(name)        
        return items.size()    
   }
}

import grails.test.GrailsUnitTestCase
class MyServiceTests extends GrailsUnitTestCase {
    void testCreateSomething() {
        // Mock the domain class.
        mockDomain(Item)

        // Mock the "other" service.
        String testId = "NH-12347686"
        def otherControl = mockFor(OtherService)
        otherControl.demand.newIdentifier(1..1) {-> return testId }

        // Initialise the service and test the target method.
        def testService = new MyService()
        testService.otherService = otherControl.createMock()

        def retval = testService.createSomething()

        // Check that the method returns the identifier returned by the
        // mock "other" service and also that a new Item instance has
        // been saved.
        def testInstances = Item.list()        
        assertEquals testId, retval
        assertEquals 1, testInstances.size()
        assertTrue testInstances[0] instanceof Item
    }

    void testCountItems() {
        // Mock the domain class, this time providing a list of test
        // Item instances that can be searched.
        def testInstances = [ new Item(code: "NH-4273997", name: "Laptop"),
                         new Item(code: "EC-4395734", name: "Lamp"),
                         new Item(code: "TF-4927324", name: "Laptop") ]
        mockDomain(Item, testInstances)
       

// Initialise the service and test the target method.

def testService = new MyService()
        assertEquals 2, testService.countItems("Laptop")
        assertEquals 1, testService.countItems("Lamp")
        assertEquals 0, testService.countItems("Chair")
    }
}

mockLogging(class, enableDebug = false)

Adds a mock "log" property to a class. Any messages passed to the mock logger are echoed to the console.

mockController(class)

Adds mock versions of the dynamic controller properties and methods to the given class. This is typically used in conjunction with the ControllerUnitTestCase class.

Mock controller properties available in unit tests

request
response
session
flash
params
redirectArgs
renderArgs
template
modelAndView

example:

class PostControllerUnitTests extends grails.test.ControllerUnitTestCase {
     void testShow() {
          mockDomain(User, [
                    new User(userId: "glen"),
                    new User(userId: "peter") ]
          this.controller.params.id = "peter"
          def model = this.controller.show()
          assertEquals "peter", model["viewUser"]?.userId
     }
}

example - action returns a model:

void testList() {
     mockDomain(Album, [ new Album(title: "Odelay"),
     new Album(title: "Abbey Road"] )
     def model = controller.list()
     assertEquals 2, model.albumList.size()
}

example - Testing the Contents of the Response:

void testIndex() {
     controller.index()
     assertEquals "Welcome to the gTunes store!", controller.response.contentAsString
}

example - contents of render args

render(view: "show", model:[album:Album.get(params.id)])

void testShow() {
     mockDomain(Album, new Album(id:1, title: "Aha Shake Heartbreak"))
     mockParams.id = 1
     controller.show()
     assertEquals "show", renderArgs.view
     assertEquals 1, renderArgs.model.album.id
     assertEquals "Aha Shake Heartbreak", renderArgs.model.album.title
}

mockParams: this property provides a mock implementation of the params object that you can populate with values before calling the controller. In addition to a mock implementation of the params object, the ControllerUnitTestCase class provides the following properties that mock various aspects of the controller API:

mockRequest
mockResponse
mockSession
mockParams
mockFlash

note:ControllerUnitTestCase not support some dynamic method. For instance: bindData(). Then is better use integration testing, or you can add this method to controller:
example:

this.controller.metaClass.bindData = { obj, params ->
           params.each { key, value ->
                       obj."$key" = value
               }
       }

this.controller.metaClass.getGrailsApplication = {-> return [config: [:]] }

example - redirect:

//in controller
redirect(controller: "post", action: "list")

// in test
assertEquals "post", this.controller.redirectArgs["controller"]
assertEquals "list", this.controller.redirectArgs["action"]

example - testing action:

def register = {
     if(request.method == 'POST') {
          def u = new User(params)
          if(u.password != params.confirm) {
                u.errors.rejectValue("password", "user.password.dontmatch")
                return [user:u]
          }else if(u.save()) {
                session.user = u
                redirect(controller:"store")
          }else {
                return [user:u]
          }

     }
}

void testRegistrationFailed() {
     mockRequest.method = 'POST'
     mockDomain(User)

     mockParams.login = ""
     def model = controller.register()

     assertNull mockSession.user
     assert model
     def user = model.user
     assert user.hasErrors()
     assertEquals "blank", user.errors.login
     assertEquals "nullable", user.errors.password
     assertEquals "nullable",
     user.errors.firstName
     assertEquals "nullable", user.errors.firstName
}

void testRegistrationSuccess() {
     mockRequest.method = 'POST'
     mockDomain(User)

     mockParams.login = "joebloggs"
     mockParams.password = "password"
     mockParams.confirm = "password"
     mockParams.firstName = "Joe"
     mockParams.lastName = "Blogs"

     def model = controller.register()

     assertEquals 'store',redirectArgs.controller
     assertNotNull mockSession.user
}

example - test Command

def login = { LoginCommand cmd ->
     if(request.method == 'POST') {
        if(!cmd.hasErrors()) {
             session.user = cmd.getUser()
             redirect(controller:'store')
        }else {
             render(view:'/store/index', model:[loginCmd:cmd])
        }
     }else {
            render(view:'/store/index')
     }
}

void testLoginUserNotFound() {
     mockRequest.method = 'POST'
     mockDomain(User)
     MockUtils.prepareForConstraintsTests(LoginCommand)
     def cmd = new LoginCommand(login:"fred", password:"letmein")
     cmd.validate()
     controller.login(cmd)
     assertTrue cmd.hasErrors()
     assertEquals "user.not.found", cmd.errors.login
     assertEquals "/store/index", renderArgs.view
}

void testLoginPasswordInvalid() {
     mockRequest.method = 'POST'
     mockDomain(User, [new User(login:"fred", password:"realpassword")])
     MockUtils.prepareForConstraintsTests(LoginCommand)
     def cmd = new LoginCommand(login:"fred", password:"letmein")
     cmd.validate()
     controller.login(cmd)
     assertTrue cmd.hasErrors()
     assertEquals "user.password.invalid", cmd.errors.password
     assertEquals "/store/index", renderArgs.view
}

void testLoginSuccess() {
     mockRequest.method = 'POST'
     mockDomain(User, [new User(login:"fred", password:"letmein")])
     MockUtils.prepareForConstraintsTests(LoginCommand)
     def cmd = new LoginCommand(login:"fred", password:"letmein")
     cmd.validate()
     controller.login(cmd)
     assertFalse cmd.hasErrors()
     assertNotNull mockSession.user
     assertEquals "store", redirectArgs.controller
}

mockTagLib(class)

Adds mock versions of the dynamic taglib properties and methods to the given class. This is typically used in conjunction with the TagLibUnitTestCase class.

example:

class MyTagLib {
     def repeat = { attrs, body ->
            attrs.times?.toInteger().times { n ->
                      body(n)
             }
      }
}

<g:repeat times="3">Hello number ${it}</g:repeat>

import grails.test.*
class MyTagLibTests extends TagLibUnitTestCase {

     MyTagLibTests() {
         super(MyTagLib)
     }

     void testRepeat() {
         tagLib.repeat(times: '2') {
            'output<br/>'
         }

     assertEquals 'output<br/>output<br/>', tagLib.out.toString()
     }
}

example:

One oddity is the empty map ([:]) as an argument, which is required because the tag
expects an attribute map as the first argument. If we were passing in at least one attri-
bute value, we could use the implicit syntax instead:
tagLib.isLoggedIn(attr1: "value") { ... }

In order to check whether the appropriate text has been generated by the tag, we
then perform a toString() on the out property and compare it to the expected value

mockConfig

In your controller you have to use org.codehaus.groovy.grails.commons.ConfigurationHolder. Then is very simple used mockConfig.

example:

private void takeOverDemoTestsets(school) {
       def String[] ids = ConfigurationHolder.config.cz.svse.testy.demo.testsets.ids.split(",")
       ids.each(){ id ->
           def testset = Testset.get(id)
           if(testset){
               school.addToTestsets( testset.clone(  school ) )
               log.info(" add testset: ${testset.title}" )              
           }
   }
}

class SchoolControllerTests extends grails.test.ControllerUnitTestCase {
  
    protected void setUp() {
       super.setUp()
           
       mockDomain(Testset, [
                   new Testset(id:1, title:"one"),
                   new Testset(id:2, title:"two")
       ])

       mockDomain(School,[])

       mockConfig ('''
               cz.svse.testy.demo.testsets.ids="1,2"
       ''')     
    }

    protected void tearDown() {
           super.tearDown()
    }
  
    void testTakeOverDemoTestsets() {
           
       def school = new School()
       assertEquals 0, school.testsets.size()

       this.controller.takeOverDemoTestsets(school)
       assertEquals 2, school.testsets.size()                
    }
}

UML - class diagram

2010-08-04T11:39:00.000-07:00

All text are from: http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell/

Class

name
attributes
operations

Inheritance

class
interface

a) class

The class BankAccount is abstract class and the method: withdrawal is abstract. Notice the italicized text. You can use stereotype abstract too.

b) interface

Asociation

Bi-directional
Uni-directional

a) Bi-directional

b) Uni-directional

Association class
In modeling an association, there are times when you need to include another class because it includes valuable information about the relationship. For this you would use an association class that you tie to the primary association. An association class is represented like a normal class.

Aggregation
An association with an aggregation relationship indicates that one class is a part of another class. In an aggregation relationship, the child class instance can outlive its parent class.

Composition
Because the relationship is a composition relationship, when the Company instance is removed/destroyed, the Department instance is automatically removed/destroyed as well. Another important feature of composition aggregation is that the part class can only be related to one instance of the parent class.

Reflexive association
A class can also be associated with itself, using a reflexive association.

Visibility

Mark	Visibility type
+	Public
#	Protected
-	Private
~	Package

Multiplicity

Indicator	Meaning
0..1	Zero or one
1	One only
0..*	Zero or more
*	Zero or more
1..*	One or more
3	Three only
0..5	Zero to Five
5..15	Five to Fifteen

XML schema

2010-08-03T01:41:00.000-07:00

All text are from http://www.w3schools.com/schema

XML Schema is an XML-based alternative to DTD.

An XML Schema:

XML Schemas are extensible to future additions
XML Schemas are richer and more powerful than DTDs
XML Schemas are written in XML
XML Schemas support data types
XML Schemas support namespaces

Example:

XML:

DTD:

XMLSchema:

The note element is a complex type because it contains other elements. The other elements (to, from, heading, body) are simple types because they do not contain other elements.

Reference to a DTD:

Reference to an XML Schema:

XSD - <schema> element

The <schema> element is the root element of every XML Schema.

Simple elements

A simple element is an XML element that can contain only text. It cannot contain any other elements or attributes.

The text can be of many different types. It can be one of the types included in the XML Schema definition (boolean, string, date, etc.), or it can be a custom type that you can define yourself.

You can also add restrictions (facets) to a data type in order to limit its content, or you can require the data to match a specific pattern.

Example:

XML

XSD

XML Schema has a lot of built-in data types. The most common types are:

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

default
<xs:element name="color" type="xs:string" default="red"/>

fixed
You cannot specify another value.
<xs:element name="color" type="xs:string" fixed="red"/>

XSD Attributes

All attributes are declared as simple types.
Simple elements cannot have attributes.

Example:
<xs:attribute name="lang" type="xs:string"/>

default
<xs:attribute name="lang" type="xs:string" default="EN"/>

fixed
<xs:attribute name="lang" type="xs:string" fixed="EN"/>

optional
<xs:attribute name="lang" type="xs:string" use="required"/>

XSD Restrictions / Facets

Restrictions are used to define acceptable values for XML elements or attributes.

Restrictions

Constraint	Description
enumeration	Defines a list of acceptable values
fractionDigits	Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero
length	Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero
maxExclusive	Specifies the upper bounds for numeric values (the value must be less than this value)
maxInclusive	Specifies the upper bounds for numeric values (the value must be less than or equal to this value)
maxLength	Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
minExclusive	Specifies the lower bounds for numeric values (the value must be greater than this value)
minInclusive	Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
minLength	Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero
pattern	Defines the exact sequence of characters that are acceptable
totalDigits	Specifies the exact number of digits allowed. Must be greater than zero
whiteSpace	Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled

Examples:

Restrictions on Values

Restrictions on a Set of Values

Restriction as pattern

Restrictions on whitespace characters
The whiteSpace constraint is set to "replace", which means that the XML processor WILL REPLACE all white space characters (line feeds, tabs, spaces, and carriage returns) with spaces:

Complex element

empty elements
elements that contain only other elements
elements that contain only text
elements that contain both other elements and text

A complex XML element, "product", which is empty:
<product pid="1345"/>

A complex XML element, "employee", which contains only other elements:
<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>

A complex XML element, "food", which contains only text:
<food type="dessert">Ice cream</food>

A complex XML element, "description", which contains both elements and text:
<description>
It happened on <date lang="norwegian">03.03.99</date> ....
</description>

Define a Complex element

The "employee" element can have a type attribute that refers to the name of the complex type to use:

If you use the method described above, several elements can refer to the same complex type, like this:

You can also base a complex element on an existing complex element and add some elements, like this:

Complex Empty Elements

An empty XML element:
<product prodid="1345" />

To define a type with no content, we must define a type that allows elements in its content, but we do not actually declare any elements, like this:

However, it is possible to declare the "product" element more compactly.

Complex Elements Only

An XML element, "person", that contains only other elements:
<person>
<firstname>John</firstname>
<lastname>Smith</lastname>
</person>

You can give the complexType element a name, and let the "person" element have a type attribute that refers to the name of the complexType (if you use this method, several elements can refer to the same complex type):

Notice the <xs:sequence> tag. It means that the elements defined ("firstname" and "lastname") must appear in that order inside a "person" element.

Text-Only Elements

Here is an example of an XML element, "shoesize", that contains text-only:
<shoesize country="france">35</shoesize>

This type contains only simple content (text and attributes), therefore we add a simpleContent element around the content. When using simple content, you must define an extension OR a restriction within the simpleContent element, like this:

Mixed Content

A mixed complex type element can contain attributes, elements, and text.

xml:

declaration:

Note: To enable character data to appear between the child-elements of "letter", the mixed attribute must be set to "true". The <xs:sequence> tag means that the elements defined (name, orderid and shipdate) must appear in that order inside a "letter" element.

Indicators

Order indicators:

All
Choice
Sequence

Occurrence indicators:

maxOccurs
minOccurs

Group indicators:

Group name
attributeGroup name

All indicator
The <all> indicator specifies that the child elements can appear in any order, and that each child element must occur only once:

Choice indicator
The <choice> indicator specifies that either one child element or another can occur:

Sequence indicator
The <sequence> indicator specifies that the child elements must appear in a specific order:

Occurrence indicators

Group indicators
Group indicators are used to define related sets of elements.

Element groups
Attribute groups

Declare Element groups:

Declare Attribute groups:

The <any> element

The <any> element enables us to extend the XML document with elements not specified by the schema.

The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <any> element we can extend (after <lastname>) the content of "person" with any element:

Schema file called “children.xsd”

The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and "children.xsd":

The <anyAttribute> element

The <anyAttribute> element enables us to extend the XML document with attributes not specified by the schema.

The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <anyAttribute> element we can add any number of attributes to the "person" element:

Schema file, called "attribute.xsd"

The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and "attribute.xsd"

Element substitution
There are way define alias for element called substitutionGroup.

now you can use:
<kunde>
<navn>tom</navn>
</kunde>

Basic data types

String
Date
Numeric
Misc

String types

String data type
The XML processor will not modify the value if you use the string data type.
<xs:element name="customer" type="xs:string"/>

NormalizedString data type
The XML processor will remove line feeds, carriage returns, and tab characters.
<xs:element name="customer" type="xs:normalizedString"/>

Token data type
The XML processor will remove line feeds, carriage returns, tabs, leading and trailing spaces, and multiple spaces.
<xs:element name="customer" type="xs:token"/>

Note: There are more String types. The other derived from String types.

Date and time types

Date type
The date is specified in the following form "YYYY-MM-DD".
<xs:element name="start" type="xs:date"/>

example:
<start>2002-09-24</start>

Time type
The time is specified in the following form "hh:mm:ss".
<xs:element name="start" type="xs:time"/>

example:
<start>09:00:00</start>

DateTime type
The dateTime is specified in the following form "YYYY-MM-DDThh:mm:ss". All components are required!
<xs:element name="startdate" type="xs:dateTime"/>

example:
<startdate>2002-05-30T09:00:00</startdate>

Duration type
The time interval is specified in the following form "PnYnMnDTnHnMnS".

P indicates the period (required)
nY indicates the number of years
nM indicates the number of months
nD indicates the number of days
T indicates the start of a time section (required if you are going to specify hours, minutes, or seconds)
nH indicates the number of hours
nM indicates the number of minutes
nS indicates the number of seconds

<xs:element name="period" type="xs:duration"/>

example:
<period>P5Y</period> <!--five years ->

Note: There are more Date and time types. The other derived from Date and time types.

Numeric data types

Decimal data type
The decimal data type is used to specify a numeric value.
<xs:element name="prize" type="xs:decimal"/>

example:
<prize>999.50</prize>

Integer data type
The integer data type is used to specify a numeric value without a fractional component.
<xs:element name="prize" type="xs:integer"/>

Note: There are more numeric types. The other derived from Decimal data type. (long, short, unsigned,...)

Miscellaneous data type

Boolean data type
Legal values for boolean are true, false, 1 (which indicates true), and 0 (which indicates false).
<xs:attribute name="disabled" type="xs:boolean"/>

example:
<prize disabled="true">999</prize>

Binary data type
We have two binary data types:

base64Binary (Base64-encoded binary data)
hexBinary (hexadecimal-encoded binary data)

<xs:element name="blobsrc" type="xs:hexBinary"/>

AnyURI data type
The anyURI data type is used to specify a URI.
<xs:attribute name="src" type="xs:anyURI"/>

example:
<pic src="http://www.w3schools.com/images/smiley.gif" />

Groovy magic

2010-07-30T02:15:00.000-07:00

All text and example are from:

Implementing the GroovyObject

Groovy's MOP system includes some extension/hooks points that you can use to change how a class or an object behaves, mainly being

getProperty/setProperty: control property access
invokeMethod: controls method invocation, you can use it to tweak parameters of existing methods or intercept not-yet existing ones
methodMissing: the preferred way to intercept non-existing methods
propertyMissing: also the preferred way to intercept non-existing properties

invokeMethod()
In any Groovy class you can override invokeMethod which will essentially intercept all method calls. Simple usage of invokeMethod is to provide simple AOP style around advice to existing methods:

class MyClass implements GroovyInterceptable {
  def invokeMethod(String name, args) {
   
      System.out.println ("Beginning $name")
       def metaMethod = metaClass.getMetaMethod(name, args)
      def result = metaMethod.invoke(this, args)
        System.out.println ("Completed $name")
      return result
  }
}

getProperty()
You can also override property access using the getProperty and setProperty property access hooks.

class Expandable {
  def storage = [:]
  def getProperty(String name) { storage[name] }
  void setProperty(String name, value) { storage[name] = value }
}

def e = new Expandable()
e.foo = "bar"
println e.foo

methodMissing

class Person {
 String name
 String sayHello( toWhom ){ "Hello $toWhom" }
}

Person.metaClass.methodMissing = { String name, args ->
 "$name() called with $args"
}

def duke = new Person(name:'Duke')
assert duke.sayHello('world') == 'Hello world'
assert duke.greet() == 'greet() called with {}'
assert duke.greet('world') == 'greet() called with {"world"}'

ExpandoMetaClass

Every object in groovy has a MetaClass, responsible for holding information about the object's class. You can obtain list of methods, add your methods and other meta-programming scenarios.

Finding method

println obj.metaClass.methods
println obj.metaClass.methods.find { it.name.startsWith("to") }

class Foo {
 String prop
 def bar() { "bar" }
 def bar(String name) { "bar $name" }
 def add(Integer one, Integer two) { one + two}
}

def f = new Foo()

if(f.metaClass.respondsTo(f, "bar")) {
 // do stuff
}

if(f.metaClass.respondsTo(f, "bar", String)) {
 // do stuff
}

if(!f.metaClass.respondsTo(f, "bar", Integer)) {
 // do stuff
}

if(f.metaClass.respondsTo(f, "add", Integer, Integer)) {
 // do stuff
}

Note method respondsTo

Finding properties

println obj.metaClass.properties
println obj.metaClass.properties.find { it.name.startsWith("to") }

class Foo {
 String prop
 def bar() { "bar" }
 def bar(String name) { "bar $name" }
 def add(Integer one, Integer two) { one + two}
}

def f = new Foo()
if(f.metaClass.hasProperty(f, "prop")) {
// do stuff
}

Note method hasProperty

Add behavour

import org.apache.commons.lang.StringUtils

String.metaClass.capitalize = {
 StringUtils.capitalize(delegate)
}

String.metaClass.normalize = {
 delegate.split("_").collect { word ->
    word.toLowerCase().capitalize()
 }.join("")
}

assert "Groovy" == "groovy".capitalize()
assert "CamelCase" == "CAMEL_CASE".normalize()

Example2

class Person {
 String name
}

Person.metaClass.greet = {
 "Hello, I'm $name"
}
def duke = new Person(name:'Duke')
assert duke.greet() == "Hello, I'm Duke"

Overload method:

Person.metaClass.whatIsThis = { String arg ->
 "it is a String with value '$arg'"
}
Person.metaClass.whatIsThis << { int arg ->
 "it is an int with value $arg"
}

assert duke.whatIsThis( 'Groovy' ) == "it is a String with value 'Groovy'"
assert duke.whatIsThis( 12345 ) == "it is an int with value 12345"

Inheritance is not enabled by default

class Person {
 String name
}
class Employee extends Person {
 int employeeId
}

Person.metaClass.greet = { -> "Hello!" }

def duke = new Person(name:'Duke')
assert duke.greet() == "Hello!"
def worker = new Employee(name:'Drone1')
// the following line causes an exception!!
assert worker.greet() == "Hello!"

Normally when you add a MetaMethod, it is added for all instances of that class. However, for GroovyObjects, you can dynamically add methods to individual instances by giving that instance its own MetaClass.

DTD

2010-07-24T02:54:00.000-07:00

All text are from http://www.w3schools.com/dtd

A Document Type Definition (DTD) defines the legal building blocks of an XML document. It defines the document structure with a list of legal elements and attributes.

A DTD can be declared:

inside XML
external reference

DTD is not XML document.

DTD inside:

DTD external

Why is DTD useful

With a DTD, each of your XML files can carry a description of its own format.
With a DTD, independent groups of people can agree to use a standard DTD for interchanging data.
Your application can use a standard DTD to verify that the data you receive from the outside world is valid.
You can also use a DTD to verify your own data.

Bulding blocks in XML

Elements
Attributes
Entities
PCDATA
CDATA

Entities
The following entities are predefined in XML:

Entity References	Character
&lt	<
&lt	<
&amp	&
"	"
'	'

PCDATA
PCDATA means parsed character data.
PCDATA is text that will be parsed by a parser. The text will be examined by the parser for entities and markup.

CDATA
CDATA means character data.
CDATA is text that will not be parsed by a parser. Tags inside the text will NOT be treated as markup and entities will not be expanded.

Elements

Declaring
<!ELEMENT element-name category>
or
<!ELEMENT element-name (element-content)>

Empty elements
<!ELEMENT br EMPTY>

Elements with PCDATA
<!ELEMENT from (#PCDATA)>

Element with children
<!ELEMENT note (to,from,heading,body)>

When children are declared in a sequence separated by commas, the children must appear in the same sequence in the document. In a full declaration, the children must also be declared, and the children can also have children. The full declaration of the "note" element is:

<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>

One occurence
<!ELEMENT note (message)>

One and more
<!ELEMENT note (message+)>

Zero and more
<!ELEMENT note (message*)>

Zero or one
<!ELEMENT note (message?)>

Either/ or content
<!ELEMENT note (to,from,header,(message|body))>

Mixed content
<!ELEMENT note (#PCDATA|to|from|header|message)*>

Attributes

Declaring attributes
<! ATTLIST element-name attribute-name attribute-type default-value>

Example:
<!ATTLIST payment type CDATA "check">

The attribute-type can be one of the following:

Type	Description
CDATA	The value is character data
(en1\|en2\|..)	The value must be one from an enumerated list
ID	The value is a unique id
IDREF	The value is the id of another element
IDREFS	The value is a list of other ids
NMTOKEN	The value is a valid XML name
NMTOKENS	The value is a list of valid XML names
ENTITY	The value is an entity
ENTITIES	The value is a list of entities
NOTATION	The value is a name of a notation
xml:	The value is a predefined xml value

The default-value can be one of the following:

Value	Explanation
value	The default value of the attribute
#REQUIRED	The attribute is required
#IMPLIED	The attribute is not required
#FIXED value	The attribute value is fixed

Default attribute value
<!ELEMENT square EMPTY>
<!ATTLIST square width CDATA "0">

In the example above, the "square" element is defined to be an empty element with a "width" attribute of type CDATA. If no width is specified, it has a default value of 0.

Enumerated values
<!ATTLIST payment type (check|cash) "cash">

Example:
<payment type="check" />
or
<payment type="cash" />

Why is elements better then attributes

Data can be stored in child elements or in attributes.

Attribute:

Element:

Some of the problems with attributes are:

attributes cannot contain multiple values (child elements can)
attributes are not easily expandable (for future changes)
attributes cannot describe structures (child elements can)
attributes are more difficult to manipulate by program code
attribute values are not easy to test against a DTD

Use attributes only to provide information that is not relevant to the data.

Example:

Entities

Entities are variables used to define shortcuts to standard text or special characters.

Entities can be declared internal or external

Internal
<!ENTITY entity-name "entity-value">

Example
<!ENTITY copyright "Copyright W3Schools.">

External
<!ENTITY entity-name SYSTEM "URI/URL">

Example
<!ENTITY writer SYSTEM "http://www.w3schools.com/entities.dtd">

XML in nutshell

2010-07-21T01:00:00.000-07:00

All text are from http://www.w3schools.com/xml/

Basic

XML was designed to transport and store data.
XML is use to:

XHTML
WSDL for describing available web services
WAP and WML as markup languages for handheld devices
RSS languages for news feeds
RDF and OWL for describing resources and ontology
SMIL for describing multimedia for the web

Syntax rules:

All XML elements must have a closing tag
XML are case sensitive
XML elements must be properly nested
XML document must have a roo element
XML attribute values must be quoted

There are 5 predefined entity references in XML:

<	<	less than
>	>	greater than
&	&	ampersand
'	'	apostrophe
"	"	quotation mark

XML elements naming rules:

Names can contain letters, numbers, and other characters
Names cannot start with a number or punctuation character
Names cannot start with the letters xml (or XML, or Xml, etc)
Names cannot contain spaces

Validation

XML with correct syntax is "Well Formed" XML.
XML validated against a DTD is "Valid" XML.

DTD (Document Type Definition )
The purpose of a DTD is to define the structure of an XML document. It defines the structure with a list of legal elements:

XML Schema
W3C supports an XML-based alternative to DTD, called XML Schema:

XML validator
http://validator.w3.org/

XML Namespace

XML Namespaces provide a method to avoid element name conflicts.
Namespaces can be declared in the elements where they are used or in the XML root element:

Note: The namespace URI is not used by the parser to look up information.
The purpose is to give the namespace a unique name. However, often companies use the namespace as a pointer to a web page containing namespace information.

In the XSLT document below, you can see that most of the tags are HTML tags.
The tags that are not HTML tags have the prefix xsl, identified by the namespace xmlns:xsl="http://www.w3.org/1999/XSL/Transform":

CDATA - (Unparsed) Character Data

The term CDATA is used about text data that should not be parsed by the XML parser.

Git a nutshell

2010-07-18T11:01:00.000-07:00

I read
http://progit.org/

I use
http://nbgit.org/

Install

Package name
$ yum install git-core
$ apt-get install git-core

Global setting
$ git config --global user.name "John Doe"
$ git config --global user.email johndoe@example.com

Local

Creating Repository

init
clone

a)
//go to project folder:
$ git init

b)
$ git clone git://github.com/schacon/grit.git myDestinationFolderName

Ignore files
//cat .gitignore
doc/*.txt
*.log

Add files
$ git add [file name, folder name, or wildcard]
$ git add submodule1/PrimaryClass.java
$ git add .
$ git add *.java

Committing
$ git commit –m ”your commit message”

Status
$ git status

What's changed
$ git diff

Remove
$ git rm log/\*.log

Show history
$ git log

Show tags
$ git tag

Tags

annotated
lightweight

a)
Add tag
$ git tag -a v1.4 -m 'my version 1.4'

Show tag
$ git show v1.4

b)
Add tag
$ git tag v1.4-lw

Remote

Show remote repositories
$ git remote -v

Add new remote repository
$ git remote add pb git://github.com/paulboone/ticgit.git

Fetch
To retrieve remote changes without merging
$ git fetch [name of remote repository]

Pull
Pulling is the combination of a fetch and a merge.
$ git pull
$ git pull [remote name]
$ git pull [remote name] [branch name]

Send your work to remote repository
$ git push origin master

Search remote repository
$ git remote show origin

Rename remote repository
$ git remote rename pb paul

Remove remote reposirory
$ git remote rm paul

Send tag to remote repository
$ git push origin v1.5
or
$ git push origin --tags

Branching

Show branches
$ git branch -a

Create new branch
$ git branch [new branch name] [from branch]
$ git branch [new branch name]

Choosing a Branch
$ git checkout [branch name]

Merging
$ git checkout master
$ git merge hotfix

Delete branch
$ git branch -d hotfix

Send local branch "serverfix" to remote branch "awesomebranch"
$ git push origin serverfix:awesomebranch

XLink and XPointer

2010-07-10T22:59:00.000-07:00

All text is from http://www.w3schools.com/xlink/

XLink defines a standard way of creating hyperlinks in XML documents.
XPointer allows the hyperlinks to point to more specific parts in the XML document.

XLink

In HTML, we know (and all the browsers know!) that the "a" element defines a hyperlink. However, this is not how it works with XML. In XML documents, you can use whatever element names you want - therefore it is impossible for browsers to predict what hyperlink elements will be called in XML documents.

To get access to the XLink attributes and features we must declare the XLink namespace at the top of the document.

example:

XPointer

If the hyperlink points to an XML document, we can add an XPointer part after the URL in the xlink:href attribute, to navigate (with an XPath expression) to a specific place in the document.

example:

XQuery

2010-07-10T01:14:00.000-07:00

All text is from www.w3schools.com/xquery/

XQuery is to XML what SQL is to database tables.

XQuery is case-sensitive and XQuery elements, attributes, and variables must be valid XML names.

FLWOR

FLWOR is an acronym for "For, Let, Where, Order by, Return".

The for clause selects all book elements under the bookstore element into a variable called $x.
The where clause selects only book elements with a price element with a value greater than 30.
The order by clause defines the sort-order. Will be sort by the title element.
The return clause specifies what should be returned. Here it returns the title elements.

XPath

2010-07-09T23:57:00.000-07:00

All text is from www.w3schools.com/XPath/

XPath is a language for finding information in an XML document.

XPath includes over 100 built-in functions. There are functions for string values, numeric values, date and time comparison, node and QName manipulation, sequence manipulation, Boolean values, and more.

In XPath, there are seven kinds of nodes:

element
attribute
text
namespace
processing-instruction
comment
document nodes

The XML Example Document

Selecting Nodes

Path Expression	Result
bookstore	Selects all the child nodes of the bookstore element
/bookstore	Selects the root element bookstore Note: If the path starts with a slash ( / ) it always represents an absolute path to an element!
bookstore/book	Selects all book elements that are children of bookstore
//book	Selects all book elements no matter where they are in the document
bookstore//book	Selects all book elements that are descendant of the bookstore element, no matter where they are under the bookstore element
//@lang	Selects all attributes that are named lang

Predicates

Predicates are always embedded in square brackets.

Path Expression	Result
/bookstore/book[1]	Selects the first book element that is the child of the bookstore element. Note: IE5 and later has implemented that [0] should be the first node, but according to the W3C standard it should have been [1]!!
/bookstore/book[last()]	Selects the last book element that is the child of the bookstore element
/bookstore/book[last()-1]	Selects the last but one book element that is the child of the bookstore element
/bookstore/book[position()<3]	Selects the first two book elements that are children of the bookstore element
//title[@lang]	Selects all the title elements that have an attribute named lang
//title[@lang='eng']	Selects all the title elements that have an attribute named lang with a value of 'eng'
/bookstore/book[price>35.00]	Selects all the book elements of the bookstore element that have a price element with a value greater than 35.00
/bookstore/book[price>35.00]/title	Selects all the title elements of the book elements of the bookstore element that have a price element with a value greater than 35.00

Wildcard

Wildcard	Description
*	Matches any element node
@*	Matches any attribute node
node()	Matches any node of any kind

In the table below we have listed some path expressions and the result of the expressions:

Path Expression	Result
/bookstore/*	Selects all the child nodes of the bookstore element
//*	Selects all elements in the document
//title[@*]	Selects all title elements which have any attribute

Selecting Several Paths

By using the | operator in an XPath expression you can select several paths.

Path Expression	Result
//book/title \| //book/price	Selects all the title AND price elements of all book elements
//title \| //price	Selects all the title AND price elements in the document
/bookstore/book/title \| //price	Selects all the title elements of the book element of the bookstore element AND all the price elements in the document

XPath Axes

AxisName	Result
ancestor	Selects all ancestors (parent, grandparent, etc.) of the current node
ancestor-or-self	Selects all ancestors (parent, grandparent, etc.) of the current node and the current node itself
attribute	Selects all attributes of the current node
child	Selects all children of the current node
descendant	Selects all descendants (children, grandchildren, etc.) of the current node
descendant-or-self	Selects all descendants (children, grandchildren, etc.) of the current node and the current node itself
following	Selects everything in the document after the closing tag of the current node
following-sibling	Selects all siblings after the current node
namespace	Selects all namespace nodes of the current node
parent	Selects the parent of the current node
preceding	Selects everything in the document that is before the start tag of the current node
preceding-sibling	Selects all siblings before the current node
self	Selects the current node

The syntax for a location step is:

axisname::nodetest[predicate]

Examples

Example	Result
child::book	Selects all book nodes that are children of the current node
attribute::lang	Selects the lang attribute of the current node
child::*	Selects all children of the current node
attribute::*	Selects all attributes of the current node
child::text()	Selects all text child nodes of the current node
child::node()	Selects all child nodes of the current node
descendant::book	Selects all book descendants of the current node
ancestor::book	Selects all book ancestors of the current node
ancestor-or-self::book	Selects all book ancestors of the current node - and the current as well if it is a book node
child::*/child::price	Selects all price grandchildren of the curren

Examples

Select all the titles

/bookstore/book/title

Select the title of the first book

/bookstore/book[1]/title

Select price nodes with price>35

/bookstore/book[price>35]/price

Select title nodes with price>35

/bookstore/book[price>35]/title

File permissions notation in Linux

2010-05-26T13:05:00.000-07:00

Every file or folder in Linux has access permissions. There are three types of permissions (what allowed to do with a file):

read access
write access
execute access

Permissions are defined for three types of users:

owner of the file
group that the owner belongs to
other users

Numeric (octal) representation

Octal digit	Text equivalent	Binary value	Meaning
0	---	000	All types of access are denied
1	--x	001	Execute access is allowed only
2	-w-	010	Write access is allowed only
3	-wx	011	Write and execute access are allowed
4	r--	100	Read access is allowed only
5	r-x	101	Read and execute access are allowed
6	rw-	110	Read and write access are allowed
7	rwx	111	Everything is allowed

Difference in access permissions for files and folders

Access type	File	Folder
Read	can read	can listing
Write	can write to file	can create, rename, delete files in direcory
Execute	can be executed	can pass through or into

Special bit

setuid: Execute file with owner permission (example: program su); -rws------; bit:4000
setgid: If file execute this with group permission.; If folder save every file into folder with folder group permission. All file in folder have been the same group.; -rwxrws---; bit:2000
sticky: If file already is not supported; If folder has sticky bit can delete files into folder only owner of file or superuser.; -rwxrwxrwt; bit:1000

File types

Regular file: -
Directory: d
Link: l
Special files: c
Socket: s
Named pipe: p
Block device: b

Examples

chmod 644 myFile.txt
chmod 4700 /bin/ls (setuid)
chmod 2770 /bin/ls (setgid)
chmod 1777 myFolder (sticky)
chown tomas myFile.txt
chgrp user myFile.txt
chown tomas.user myFile.txt

VPN client server configuration

2010-04-14T06:26:00.000-07:00

In our company we need to allow certain members access to our computer network from the outside. Therefore, we decided to get a VPN.

We choose OpenVPN, because it is Open Source and it is available for Linux, Windows and another OS.

You can let running VPN server on Linux and let blunt Windows client to connect to server.

For server-client configuration you need to generate keys and certificates, but configuration is very simple.

Server configuration

/etc/openvpn/server.conf


port 1194
proto tcp
dev tun
keepalive 10 60
comp-lzo

server  10.10.1.0 255.255.255.0
ifconfig-pool-persist /etc/openvpn/ipp.txt
max-clients 3

push "route 172.16.128.0 255.255.255.0"
push "dhcp-option DNS 172.16.128.1"

ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/akela.crt
key /etc/openvpn/keys/akela.key
dh /etc/openvpn/keys/dh1024.pem
tls-auth /etc/openvpn/keys/static.key

log-append /var/log/openvpn.log
status /var/log/openvpn-status.log
mute 10
verb 5

All important you find out in man pages or on project documentation.

push "dhcp-option DNS 172.16.128.1" get only Windows client. For Linux client you need script. See HOWTO

Generate certificates

You can use OpenSSL, but developers of OpenVPN prepare scripts for simply generate keys and certificates for server and clients.

You find out it: /user/share/doc/openvpn/examples/easy-rsa/2.0/

Scripts config file is vars. There you can set same variables.

1. We load the config file to system, and create self-signed Certificate Authority


. ./vars
./clean-all
./build-ca

In folder keys (depend on your vars files) you find out file:

ca.pem - public certificate
ca.key - private key of Certificate Authority

2. we create key and certificate for server.


./build-key-server akela

It creates file:

akela.pem - certificate of your server signed of your CA
akela.ctr - request of sign (you don´t need that file)
akela.key - private key of your server

3. we create Deffie-Hellmann parameters for dynamic key encryption


./build-df

It creates file:

dh1024.pem

4. we create static TLS-AUTH key


openvpn --genkey --secret static.key

It creates file:

static.key

Client configuration

We need to create certificate for your client.

In your server use:


./build-key kibo

kibo.pem - certificate of your client(notebook) signed of your CA
kibo.ctr - request of sign (you don´t need that file)
kibo.key - private key of your client(notebook)

In your client(notebook) save this file:

kibo.pem
kibo.key
ca.pem
static.key

Clinet configuration on /etc/openvpn/client.conf in Linux client.

Clinet configuration on ..\ProgramFiles\OpenVPN\Config\client.ovpn in Windows client.


client
pull
dev tun
proto tcp
remote ourServer.tld

ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/kibo.crt
key /etc/openvpn/keys/kibo.key
tls-auth /etc/openvpn/keys/static.key

comp-lzo
verb 4
mute 10
ns-cert-type server

Start server and then try to connect from client.

openvpn /etc/openvpn/server.conf - on Linux server (or as service)
openvpn /etc/openvpn/client.conf - on Linux client(notebook)

OpenVPN and IPTables


$IPTABLES -A INPUT -p tcp --dport 1194 -j ACCEPT       # VPN new
$IPTABLES -A INPUT -i tun+             -j ACCEPT       # VPN tun
$IPTABLES -A FORWARD -i tun+ -o $LAN_IFACE -j ACCEPT   # VPN forward >
$IPTABLES -A FORWARD -i $LAN_IFACE -o tun+ -j ACCEPT   # VPN forward <

Good Luck.

www.harvart.cz with Grails

2010-04-05T23:38:00.000-07:00

For us last web project www.harvart.cz we used Grails framework.
Earlier we used Spring MVC with Spring Roo for all us projects.
We are really excited to work with Grails framework.
Let mi introduce same of features in Grails:

Rapid development

We don´t often restart Tomcat. After changes in controller classes, gsp pages or config classes is project automatically reloaded. When you add or change same bean in Spring context, it automatically reload too. It is very comfortable behaviour.

URL mapping

For URL mapping Grails use simple mapping file:

"/clanky"(controller:'article', action:'all')
"/clanky/$url"(controller:'article', action:'show')
"/klub"(controller:'klub', action:'about')
"/fotogalerie"(controller:'gallery', action:'all')
"/fotogalerie/$url"(controller:'gallery', action:'show')

You only determine which controller and action is conjunction with url. When you use Grails link tag then the url is automatically compile in all your HTML links. It is grait!

GORM

Every domain class has automatically all GRUD methods. You don´t need to write boring DAO classes.

Plugins

There are a lot of useful plugins. You only install same plugin and you can use it immediately. In www.harvart.cz we used search plugin. We only marked domain class, which can be search. It is unbelievably simply!

Conclusion

Grails is great! As developer you can concentrate to write your own code only. Groovy give you all you need as web developer. You can use all for Spring, Hibernate and SiteMesh.

Kibo world

DCS-950G streaming in Linux

Google Web Toolkit RPC

Making GWT Remote Procedure Calls

Modul

UI

Service implementation

XSLT

XSLT

XSLT - Transformation

<xsl:template>

<xsl:value-of>

<xsl:for-each>

Filtering

<xsl:sort>

<xsl:if>

<xsl:choose>

<xsl:apply-templates>

Grails: Unit testing

mockDomain(class, testInstances)

mockForConstraintsTests(class, testInstances)

mockFor(class)

mockLogging(class, enableDebug = false)

mockController(class)

mockTagLib(class)

mockConfig

UML - class diagram

Class

Inheritance

Asociation

Visibility

Multiplicity

XML schema

XSD - <schema> element

Simple elements

XSD Attributes

XSD Restrictions / Facets

Complex element

Define a Complex element

Complex Empty Elements

Complex Elements Only

Text-Only Elements

Mixed Content

Indicators

The <any> element

The <anyAttribute> element

Basic data types

String types

Date and time types

Numeric data types

Miscellaneous data type

Groovy magic

Implementing the GroovyObject

ExpandoMetaClass

Every object in groovy has a MetaClass, responsible for holding information about the object's class. You can obtain list of methods, add your methods and other meta-programming scenarios.

Categories

DTD

Why is DTD useful

Bulding blocks in XML

Elements

Attributes

Why is elements better then attributes

Entities

XML in nutshell

Basic

Validation

XML Namespace

CDATA - (Unparsed) Character Data

Git a nutshell

Install

Local

Remote

Branching

XLink and XPointer

XLink

XPointer

XQuery

FLWOR

XPath

All text is from www.w3schools.com/XPath/