-
Notifications
You must be signed in to change notification settings - Fork 2
/
push.go
140 lines (115 loc) · 2.8 KB
/
push.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package cli
import (
"context"
"flag"
"fmt"
"os"
"os/exec"
"sync"
"time"
"github.com/emiraganov/sharef/cli/sdp"
"github.com/emiraganov/sharef/deamon"
"github.com/emiraganov/sharef/errx"
"github.com/emiraganov/sharef/streamer"
"github.com/emiraganov/sharef/watcher"
"github.com/emiraganov/goextra/osx"
log "github.com/sirupsen/logrus"
)
func Push(args []string) {
flagset := flag.NewFlagSet("push", flag.ExitOnError)
var daemonize = flagset.Bool("d", false, "- Daemonize Sender, you must kill it")
var keepsync = flag.Bool("f", false, "- Stream/Sync files")
flagset.Parse(args)
args = flagset.Args()
//Check do we deamonize
if *daemonize {
bootstrapSenderDeamon()
return
}
//Check do we have deamon running
cdaemon := deamon.InitSenderDeamonClient()
if cdaemon != nil {
cdaemon.ProcessArgs(args)
return
}
//Proceed with normal streaming
if err := sendFiles(args, *keepsync); err != nil {
fmt.Println(err.Error())
}
}
func bootstrapSenderDeamon() {
name := os.Args[0]
if name == "" {
name = "sharef"
}
cmd := exec.Command(name, "deamon")
cmd.Stdout = os.Stdout
cmd.Stdin = os.Stdin
fmt.Println("Starting deamon, please wait...")
if err := cmd.Start(); err != nil {
log.Fatal(err)
}
//Now client needs to fulfil SDP connections
var running bool
for i := 0; i < 300; i++ {
time.Sleep(1 * time.Second) //Give some timeout for boot
s := deamon.InitSenderDeamonClient()
if s != nil {
running = true
fmt.Println("Deamon is up and running")
s.Close() //Close connection
break
}
}
if !running {
fmt.Println("Timeout")
cmd.Process.Kill()
return
}
if err := cmd.Process.Release(); err != nil {
log.Fatal(err)
}
// cmd.Wait()
}
func sendFiles(args []string, keepsync bool) error {
//Check do file exists
for _, file := range args {
if !osx.CheckFileExists(file) {
return fmt.Errorf("File %s does not exist", file)
}
}
//Sender
reader, writer := sdp.SenderPipe() //This will send prompts and offer/answer from stdin,stdout
sess := streamer.NewSession(reader, writer)
s := streamer.NewSender(sess)
if err := s.Dial(); err != nil {
return errx.Wrapf(err, "Dial failed")
}
defer s.Close()
//Stream files
fmt.Println("")
fmt.Println("Sending files:")
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
for _, file := range args {
fi, err := os.Stat(file)
if err != nil {
return err
}
streamer := s.NewFileStreamer(file)
if keepsync {
w := watcher.New(file, fi)
go w.ListenChangeFile(ctx, func(fin os.FileInfo, path string) error {
return streamer.SubStream(fin, path)
})
}
if err := streamer.Stream(ctx, fi); err != nil {
return errx.Wrapf(err, "Streaming %s file failed", file)
}
}
return nil
}
func sendStreamerWait(s *streamer.SendStreamer, wg *sync.WaitGroup) {
<-s.Done
wg.Done()
}