2013-03-30 13:55:47 +00:00
|
|
|
package docker
|
|
|
|
|
|
|
|
import (
|
2013-05-10 04:55:08 +00:00
|
|
|
"bufio"
|
2013-03-30 13:55:47 +00:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2013-05-10 04:55:08 +00:00
|
|
|
_ "io/ioutil"
|
|
|
|
"strings"
|
2013-03-30 13:55:47 +00:00
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
func closeWrap(args ...io.Closer) error {
|
|
|
|
e := false
|
|
|
|
ret := fmt.Errorf("Error closing elements")
|
|
|
|
for _, c := range args {
|
|
|
|
if err := c.Close(); err != nil {
|
|
|
|
e = true
|
|
|
|
ret = fmt.Errorf("%s\n%s", ret, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if e {
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2013-05-10 04:55:08 +00:00
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {
|
2013-03-30 13:55:47 +00:00
|
|
|
c := make(chan bool)
|
|
|
|
|
|
|
|
// Make sure we are not too long
|
|
|
|
go func() {
|
|
|
|
time.Sleep(d)
|
|
|
|
c <- true
|
|
|
|
}()
|
2013-04-01 03:52:35 +00:00
|
|
|
go func() {
|
|
|
|
f()
|
|
|
|
c <- false
|
|
|
|
}()
|
|
|
|
if <-c {
|
|
|
|
t.Fatal(msg)
|
2013-03-30 13:55:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error {
|
|
|
|
for i := 0; i < count; i++ {
|
|
|
|
if _, err := w.Write([]byte(input)); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
o, err := bufio.NewReader(r).ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if strings.Trim(o, " \r\n") != output {
|
|
|
|
return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", output, o)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-05-10 04:55:08 +00:00
|
|
|
/*TODO
|
2013-04-11 23:21:19 +00:00
|
|
|
func cmdWait(srv *Server, container *Container) error {
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
srv.CmdWait(nil, stdoutPipe, container.Id)
|
|
|
|
}()
|
|
|
|
|
|
|
|
if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// Cleanup pipes
|
|
|
|
return closeWrap(stdout, stdoutPipe)
|
|
|
|
}
|
|
|
|
|
2013-05-03 16:47:52 +00:00
|
|
|
func cmdImages(srv *Server, args ...string) (string, error) {
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
if err := srv.CmdImages(nil, stdoutPipe, args...); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// force the pipe closed, so that the code below gets an EOF
|
|
|
|
stdoutPipe.Close()
|
|
|
|
}()
|
|
|
|
|
|
|
|
output, err := ioutil.ReadAll(stdout)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Cleanup pipes
|
|
|
|
return string(output), closeWrap(stdout, stdoutPipe)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestImages checks that 'docker images' displays information correctly
|
|
|
|
func TestImages(t *testing.T) {
|
|
|
|
|
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
|
|
|
output, err := cmdImages(srv)
|
|
|
|
|
|
|
|
if !strings.Contains(output, "REPOSITORY") {
|
|
|
|
t.Fatal("'images' should have a header")
|
|
|
|
}
|
|
|
|
if !strings.Contains(output, "docker-ut") {
|
|
|
|
t.Fatal("'images' should show the docker-ut image")
|
|
|
|
}
|
|
|
|
if !strings.Contains(output, "e9aa60c60128") {
|
|
|
|
t.Fatal("'images' should show the docker-ut image id")
|
|
|
|
}
|
|
|
|
|
|
|
|
output, err = cmdImages(srv, "-q")
|
|
|
|
|
|
|
|
if strings.Contains(output, "REPOSITORY") {
|
|
|
|
t.Fatal("'images -q' should not have a header")
|
|
|
|
}
|
|
|
|
if strings.Contains(output, "docker-ut") {
|
|
|
|
t.Fatal("'images' should not show the docker-ut image name")
|
|
|
|
}
|
|
|
|
if !strings.Contains(output, "e9aa60c60128") {
|
|
|
|
t.Fatal("'images' should show the docker-ut image id")
|
|
|
|
}
|
|
|
|
|
|
|
|
output, err = cmdImages(srv, "-viz")
|
|
|
|
|
|
|
|
if !strings.HasPrefix(output, "digraph docker {") {
|
|
|
|
t.Fatal("'images -v' should start with the dot header")
|
|
|
|
}
|
|
|
|
if !strings.HasSuffix(output, "}\n") {
|
|
|
|
t.Fatal("'images -v' should end with a '}'")
|
|
|
|
}
|
|
|
|
if !strings.Contains(output, "base -> \"e9aa60c60128\" [style=invis]") {
|
|
|
|
t.Fatal("'images -v' should have the docker-ut image id node")
|
|
|
|
}
|
|
|
|
|
|
|
|
// todo: add checks for -a
|
|
|
|
}
|
|
|
|
|
2013-04-03 02:00:05 +00:00
|
|
|
// TestRunHostname checks that 'docker run -h' correctly sets a custom hostname
|
|
|
|
func TestRunHostname(t *testing.T) {
|
2013-04-05 03:08:58 +00:00
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
|
|
|
stdin, _ := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
|
|
|
|
c := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
if err := srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-h", "foobar", GetTestImage(runtime).Id, "hostname"); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
close(c)
|
|
|
|
}()
|
|
|
|
cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if cmdOutput != "foobar\n" {
|
|
|
|
t.Fatalf("'hostname' should display '%s', not '%s'", "foobar\n", cmdOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
setTimeout(t, "CmdRun timed out", 2*time.Second, func() {
|
|
|
|
<-c
|
2013-04-11 23:21:19 +00:00
|
|
|
cmdWait(srv, srv.runtime.List()[0])
|
2013-04-05 03:08:58 +00:00
|
|
|
})
|
2013-04-11 23:21:19 +00:00
|
|
|
|
2013-04-03 02:00:05 +00:00
|
|
|
}
|
|
|
|
|
2013-04-02 16:22:30 +00:00
|
|
|
func TestRunExit(t *testing.T) {
|
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
2013-04-08 23:06:55 +00:00
|
|
|
srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
|
2013-04-02 16:22:30 +00:00
|
|
|
close(c1)
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
container := runtime.List()[0]
|
|
|
|
|
|
|
|
// Closing /bin/cat stdin, expect it to exit
|
|
|
|
p, err := container.StdinPipe()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if err := p.Close(); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// as the process exited, CmdRun must finish and unblock. Wait for it
|
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
|
|
<-c1
|
2013-04-11 23:21:19 +00:00
|
|
|
cmdWait(srv, container)
|
2013-04-02 16:22:30 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
// Make sure that the client has been disconnected
|
|
|
|
setTimeout(t, "The client should have been disconnected once the remote process exited.", 2*time.Second, func() {
|
2013-04-02 19:18:20 +00:00
|
|
|
// Expecting pipe i/o error, just check that read does not block
|
|
|
|
stdin.Read([]byte{})
|
2013-04-02 16:22:30 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
// Cleanup pipes
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
// Expected behaviour: the process dies when the client disconnects
|
|
|
|
func TestRunDisconnect(t *testing.T) {
|
2013-03-30 13:55:47 +00:00
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
srv := &Server{runtime: runtime}
|
2013-03-30 13:55:47 +00:00
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
2013-04-02 18:06:42 +00:00
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdRun returns.
|
2013-04-05 02:00:14 +00:00
|
|
|
srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
|
2013-04-01 03:52:35 +00:00
|
|
|
close(c1)
|
|
|
|
}()
|
2013-03-30 13:55:47 +00:00
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
2013-03-30 13:55:47 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-04-01 03:52:35 +00:00
|
|
|
})
|
2013-03-30 13:55:47 +00:00
|
|
|
|
2013-04-06 02:02:35 +00:00
|
|
|
// Close pipes (simulate disconnect)
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// as the pipes are close, we expect the process to die,
|
|
|
|
// therefore CmdRun to unblock. Wait for CmdRun
|
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
|
|
<-c1
|
|
|
|
})
|
|
|
|
|
|
|
|
// Client disconnect after run -i should cause stdin to be closed, which should
|
|
|
|
// cause /bin/cat to exit.
|
|
|
|
setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
|
|
|
|
container := runtime.List()[0]
|
|
|
|
container.Wait()
|
|
|
|
if container.State.Running {
|
|
|
|
t.Fatalf("/bin/cat is still running after closing stdin")
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Expected behaviour: the process dies when the client disconnects
|
|
|
|
func TestRunDisconnectTty(t *testing.T) {
|
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdRun returns.
|
|
|
|
srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-t", GetTestImage(runtime).Id, "/bin/cat")
|
|
|
|
close(c1)
|
|
|
|
}()
|
|
|
|
|
2013-04-22 18:16:32 +00:00
|
|
|
setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
|
|
|
|
for {
|
|
|
|
// Client disconnect after run -i should keep stdin out in TTY mode
|
|
|
|
l := runtime.List()
|
|
|
|
if len(l) == 1 && l[0].State.Running {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
// Client disconnect after run -i should keep stdin out in TTY mode
|
|
|
|
container := runtime.List()[0]
|
|
|
|
|
2013-04-06 02:02:35 +00:00
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
// Close pipes (simulate disconnect)
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-03-30 13:55:47 +00:00
|
|
|
|
2013-04-20 00:51:41 +00:00
|
|
|
// In tty mode, we expect the process to stay alive even after client's stdin closes.
|
|
|
|
// Do not wait for run to finish
|
2013-04-01 03:52:35 +00:00
|
|
|
|
2013-04-09 15:18:36 +00:00
|
|
|
// Give some time to monitor to do his thing
|
|
|
|
container.WaitTimeout(500 * time.Millisecond)
|
|
|
|
if !container.State.Running {
|
|
|
|
t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)")
|
|
|
|
}
|
2013-03-30 13:55:47 +00:00
|
|
|
}
|
2013-04-01 04:48:18 +00:00
|
|
|
|
2013-04-03 01:05:19 +00:00
|
|
|
// TestAttachStdin checks attaching to stdin without stdout and stderr.
|
|
|
|
// 'docker run -i -a stdin' should sends the client's stdin to the command,
|
|
|
|
// then detach from it and print the container id.
|
2013-04-05 03:08:58 +00:00
|
|
|
func TestRunAttachStdin(t *testing.T) {
|
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
|
|
|
|
ch := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-a", "stdin", GetTestImage(runtime).Id, "sh", "-c", "echo hello; cat")
|
|
|
|
close(ch)
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Send input to the command, close stdin
|
|
|
|
setTimeout(t, "Write timed out", 2*time.Second, func() {
|
|
|
|
if _, err := stdinPipe.Write([]byte("hi there\n")); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if err := stdinPipe.Close(); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
container := runtime.List()[0]
|
|
|
|
|
|
|
|
// Check output
|
|
|
|
cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if cmdOutput != container.ShortId()+"\n" {
|
|
|
|
t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ShortId()+"\n", cmdOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
// wait for CmdRun to return
|
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
|
|
<-ch
|
|
|
|
})
|
|
|
|
|
|
|
|
setTimeout(t, "Waiting for command to exit timed out", 2*time.Second, func() {
|
|
|
|
container.Wait()
|
|
|
|
})
|
|
|
|
|
|
|
|
// Check logs
|
|
|
|
if cmdLogs, err := container.ReadLog("stdout"); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
} else {
|
|
|
|
if output, err := ioutil.ReadAll(cmdLogs); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
} else {
|
|
|
|
expectedLog := "hello\nhi there\n"
|
|
|
|
if string(output) != expectedLog {
|
|
|
|
t.Fatalf("Unexpected logs: should be '%s', not '%s'\n", expectedLog, output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-03-30 13:55:47 +00:00
|
|
|
}
|
2013-04-01 04:48:18 +00:00
|
|
|
|
|
|
|
// Expected behaviour, the process stays alive when the client disconnects
|
|
|
|
func TestAttachDisconnect(t *testing.T) {
|
|
|
|
runtime, err := newTestRuntime()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer nuke(runtime)
|
|
|
|
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
|
2013-04-24 22:35:28 +00:00
|
|
|
container, err := NewBuilder(runtime).Create(
|
2013-04-01 04:48:18 +00:00
|
|
|
&Config{
|
|
|
|
Image: GetTestImage(runtime).Id,
|
|
|
|
Memory: 33554432,
|
|
|
|
Cmd: []string{"/bin/cat"},
|
|
|
|
OpenStdin: true,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer runtime.Destroy(container)
|
|
|
|
|
|
|
|
// Start the process
|
|
|
|
if err := container.Start(); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
|
|
|
|
|
|
|
// Attach to it
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
2013-04-02 18:06:42 +00:00
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdAttach returns.
|
2013-04-05 02:00:14 +00:00
|
|
|
srv.CmdAttach(stdin, rcli.NewDockerLocalConn(stdoutPipe), container.Id)
|
2013-04-01 04:48:18 +00:00
|
|
|
close(c1)
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
// Close pipes (client disconnects)
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for attach to finish, the client disconnected, therefore, Attach finished his job
|
|
|
|
setTimeout(t, "Waiting for CmdAttach timed out", 2*time.Second, func() {
|
|
|
|
<-c1
|
|
|
|
})
|
2013-04-02 19:18:20 +00:00
|
|
|
|
2013-04-01 04:48:18 +00:00
|
|
|
// We closed stdin, expect /bin/cat to still be running
|
|
|
|
// Wait a little bit to make sure container.monitor() did his thing
|
|
|
|
err = container.WaitTimeout(500 * time.Millisecond)
|
|
|
|
if err == nil || !container.State.Running {
|
|
|
|
t.Fatalf("/bin/cat is not running after closing stdin")
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to avoid the timeoout in destroy. Best effort, don't check error
|
|
|
|
cStdin, _ := container.StdinPipe()
|
|
|
|
cStdin.Close()
|
2013-04-23 18:09:48 +00:00
|
|
|
container.Wait()
|
2013-04-01 04:48:18 +00:00
|
|
|
}
|
2013-05-06 09:31:22 +00:00
|
|
|
*/
|