func parseGauges(info string) map[string]int64 {
gauges_with_values := map[string]int64{
"blocked_clients": 0,
"connected_clients": 0,
"instantaneous_ops_per_sec": 0,
"latest_fork_usec": 0,
"mem_fragmentation_ratio": 0,
"migrate_cached_sockets": 0,
"pubsub_channels": 0,
"pubsub_patterns": 0,
"uptime_in_seconds": 0,
"used_memory": 0,
"used_memory_lua": 0,
"used_memory_peak": 0,
"used_memory_rss": 0,
}
color.White("-------------------")
color.White("GAUGES:")
for gauge, _ := range gauges_with_values {
r, _ := regexp.Compile(fmt.Sprint(gauge, ":([0-9]*)"))
matches := r.FindStringSubmatch(info)
if matches == nil {
color.Yellow(fmt.Sprint("WARN: ", gauge, "is not displayed in redis info"))
} else {
value := matches[len(matches)-1]
color.Cyan(fmt.Sprint(gauge, ": ", value))
v, _ := strconv.ParseInt(value, 10, 64)
gauges_with_values[gauge] = v
}
}
return gauges_with_values
}
func Start() {
if os.Getenv("IMGSTORAGE_LOCATION") != "" {
ImgStoragePath = os.Getenv("IMGSTORAGE_LOCATION")
} else {
reader := bufio.NewReader(os.Stdin)
color.Cyan("Enter location of image storage: ")
ImgStoragePath, _ = reader.ReadString('\n')
}
cio.PrintMessage(1, "Image storage is being created...")
if _, err := os.Stat(ImgStoragePath); os.IsNotExist(err) {
// doesn't exist
os.Mkdir(ImgStoragePath, 0776)
cio.PrintMessage(2, (ImgStoragePath + " created."))
} else {
cio.PrintMessage(2, (ImgStoragePath + " already existed."))
}
if os.Getenv("IMG_NAME_LENGTH") != "" {
ImgNameLength, _ = strconv.Atoi(os.Getenv("IMG_NAME_LENGTH"))
} else {
reader := bufio.NewReader(os.Stdin)
color.Cyan("Enter length of image names: ")
temp, _ := reader.ReadString('\n')
ImgNameLength, _ = strconv.Atoi(temp)
}
}
// TEST="asdf,asdf,asdf" ./main template.tpl
func main() {
if len(os.Args) != 2 {
color.Red("tenv: v.01")
color.Blue("------------------------")
color.Cyan("Prepopulates to stdin given template with information stored in env variables")
color.Cyan("variables should follow go template syntax {{.VAR_NAME}}")
color.Cyan("and must be declared on the environment")
color.Cyan("Usage : tenv filename")
os.Exit(1)
}
var funcMap template.FuncMap
funcMap = template.FuncMap{
"split": strings.Split,
}
file := filepath.Base(os.Args[1])
t, err := template.New(file).Funcs(funcMap).ParseFiles(os.Args[1])
if err != nil {
log.Fatalf("Error: %s", err)
}
context := make(map[string]string)
for _, v := range os.Environ() {
p := strings.Split(v, "=")
context[p[0]] = p[1]
}
err = t.ExecuteTemplate(os.Stdout, file, context)
if err != nil {
log.Fatal(err)
}
}
// Start is the database package launch method
// it enters or fetches the data required for the database
func Start() {
/*
* allow user to enter db data
* used instead of environment variables
* if there are none
* since the service is open source
*/
var (
uname string
pw string
name string
)
if os.Getenv("DB_UNAME") == "" && os.Getenv("DB_NAME") == "" {
reader := bufio.NewReader(os.Stdin)
color.Cyan("Enter db user name: ")
uname, _ = reader.ReadString('\n')
color.Cyan("Enter db pw: ")
pw, _ = reader.ReadString('\n')
color.Cyan("Enter db name: ")
name, _ = reader.ReadString('\n')
} else {
uname = os.Getenv("DB_UNAME")
pw = os.Getenv("DB_PW")
name = os.Getenv("DB_NAME")
}
var err error
db, err = sql.Open("postgres",
"user="******" password="******" dbname="+name+
" sslmode=disable")
if err != nil {
cio.PrintMessage(1, err.Error())
return
}
// test connection
err = db.Ping()
if err != nil { // connection not successful
cio.PrintMessage(1, err.Error())
var rundb string
reader := bufio.NewReader(os.Stdin)
color.Cyan("Do you want to run the server without a working database module? (y/n) ")
rundb, _ = reader.ReadString('\n')
if rundb != "y\n" && rundb != "Y\n" {
os.Exit(-1)
}
}
}
// conect to server operation
func connect(matched []Server, printOnly bool) {
if len(matched) == 0 {
color.Cyan("No server match patterns")
} else if len(matched) == 1 {
color.Green("%s", matched[0].getConnectionString())
if !printOnly {
matched[0].connect()
}
} else {
color.Cyan("Multiple servers match patterns:")
for _, s := range matched {
color.White(s.getConnectionString())
}
}
}
// download file from server operation
func download(src string, dest string, matched []Server, printOnly bool) {
if len(matched) == 0 {
color.Cyan("No server match patterns")
} else if len(matched) == 1 {
color.Green("%s", matched[0].getDownloadString(src, dest))
if !printOnly {
matched[0].download(src, dest)
}
} else {
color.Cyan("Multiple servers match patterns:")
for _, s := range matched {
color.White(s.getDownloadString(src, dest))
}
}
}
func TesTFetchingJob(t *testing.T) {
out, _ := jobworker.FetchJob("parsebin")
color.Cyan(out)
}
// Build listens watch events from Watcher and sends messages to Runner
// when new changes are built.
func (b *Builder) Build(p *Params) {
go b.registerSignalHandler()
go func() {
b.watcher.update <- true
}()
for <-b.watcher.Wait() {
fileName := p.createBinaryName()
pkg := p.GetPackage()
color.Cyan("Building %s...\n", pkg)
// build package
cmd, err := runCommand("go", "build", "-o", fileName, pkg)
if err != nil {
log.Fatalf("Could not run 'go build' command: %s", err)
continue
}
if err := cmd.Wait(); err != nil {
if err := interpretError(err); err != nil {
color.Red("An error occurred while building: %s", err)
} else {
color.Red("A build error occurred. Please update your code...")
}
continue
}
// and start the new process
b.runner.restart(fileName)
}
}
func parseCounters(info string) map[string]int64 {
counters := map[string]int64{
"evicted_keys": 0,
"expired_keys": 0,
"keyspace_hits": 0,
"keyspace_misses": 0,
"rejected_connections": 0,
"sync_full": 0,
"sync_partial_err": 0,
"sync_partial_ok": 0,
"total_commands_processed": 0,
"total_connections_received": 0,
}
color.White("-------------------")
color.White("COUNTERS:")
for counter, _ := range counters {
r, _ := regexp.Compile(fmt.Sprint(counter, ":([0-9]*)"))
matches := r.FindStringSubmatch(info)
if matches == nil {
color.Yellow(fmt.Sprint("ERROR: ", counter, "is not displayed in redis info"))
} else {
value := matches[len(matches)-1]
color.Cyan(fmt.Sprint(counter, ": ", value))
v, _ := strconv.ParseInt(value, 10, 64)
counters[counter] = v
}
}
return counters
}
func writeDebug(format string, a ...interface{}) {
if !debug {
return
}
color.Cyan(format, a...)
}
func TesTGettingJobInfo(t *testing.T) {
jid := jobworker.GetPendingJids("parsebin")
out := jobworker.GetJobInfo("parsebin", jid)
color.Cyan(out)
}
func PrintMessage(cl int, msg string) {
if cl == 0 {
color.Green("[pixmate] %s", msg)
} else if cl == 1 {
color.Red("[pixmate] %s", msg)
} else if cl == 2 {
color.Cyan("[pixmate] %s", msg)
}
}
func (this *Options) Usage() {
var banner string = ` ____ _
| _ \ ___ _ __ | | __ _ ___ ___
| |_) / _ \ '_ \| |/ _' |/ __/ _ \
| _ < __/ |_) | | (_| | (_| __/
|_| \_\___| .__/|_|\__'_|\___\___|
|_|
`
color.Cyan(banner)
flag.Usage()
}
// Do accepts a function argument that returns an error. It will keep executing this
// function NumRetries times until no error is returned.
// Optionally pass another function as an argument that it will execute before retrying
// in case an error is returned from the first argument fuction.
func Do(args ...interface{}) error {
if len(args) == 0 {
panic("Wrong number of arguments")
}
task, ok := args[0].(func() error)
beforeRetry := func() {}
if len(args) > 1 {
beforeRetry, ok = args[1].(func())
}
if ok == false {
panic("Wrong Type of Arguments given to retry.Do")
}
retries := NumRetries
var atleastOneError error
atleastOneError = nil
err := errors.New("Non-Nil error")
for retries > 0 && err != nil {
err = task()
if err != nil {
atleastOneError = err
color.Magenta("\nError: %v\nRetrying #%d after %v", err, (NumRetries - retries + 1), Delay)
time.Sleep(Delay)
beforeRetry()
}
retries = retries - 1
}
if err != nil {
color.Red("\nError even after %d retries:\n%v", NumRetries, err)
if PanicEnabled == true {
panic(err)
}
return err
}
if atleastOneError != nil {
color.Cyan("\nRecovered from error: %v in %d tries\n", atleastOneError, (NumRetries - retries - 1))
}
return err
}
func show(dict Dict) {
for _, ps := range dict.Ps {
color.Green(ps)
}
for index, pos := range dict.Pos {
color.Red(strings.TrimSpace(pos))
color.Yellow(strings.TrimSpace(dict.Acceptation[index]))
}
for _, sent := range dict.SentList {
color.Blue("ex. %s", strings.TrimSpace(sent.Orig))
color.Cyan(" %s", strings.TrimSpace(sent.Trans))
}
}
func printSSHKeys(v *vaulted.Vault) {
color.Cyan("\nSSH Keys:")
if len(v.SSHKeys) > 0 {
keys := []string{}
for key := range v.SSHKeys {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
green.Printf(" %s\n", key)
}
} else {
print(" [Empty]")
}
}
func main() {
url := flag.String("url", "", "webservice url")
count := flag.Int("count", 1, "requests count")
stats := flag.Bool("stats", false, "print stats only")
method := flag.String("method", "GET", "http method (POST or GET)")
flag.Parse()
if len(*url) == 0 {
fmt.Println("Missing param url")
return
}
httpFunc := get
if *method == "POST" {
httpFunc = post
}
responses := make(chan int, *count)
for i := 0; i < *count; i++ {
go httpFunc(responses, *url)
}
respMap := make(map[int]int)
for i := 0; i < *count; i++ {
statusCode := <-responses
respMap[statusCode]++
if *stats {
continue
}
statusMsg := fmt.Sprintf("%d :: %d", i, statusCode)
if statusCode != 200 {
color.Red(statusMsg)
} else {
color.Cyan(statusMsg)
}
}
if *stats {
for k, v := range respMap {
fmt.Printf("%d :: %-5d\n", k, v)
}
}
}
func printVariables(v *vaulted.Vault) {
color.Cyan("\nVariables:")
if len(v.Vars) > 0 {
var keys []string
for key := range v.Vars {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
green.Printf(" %s: ", key)
fmt.Printf("%s\n", v.Vars[key])
}
} else {
print(" [Empty]")
}
}
func promptUserToSelectModule(modules []Module, optional bool) (Module, error) {
// Prompt the user to select a module.
kind := modules[0].Kind()
for {
// Write the dialog into the console.
ctx := &dialogTemplateContext{
Kind: string(kind),
Modules: modules,
Optional: optional,
}
if err := dialogTemplate.Execute(os.Stdout, ctx); err != nil {
return nil, err
}
// Prompt the user for the answer.
// An empty answer is aborting the dialog.
answer, err := prompt.Prompt("You choice: ")
if err != nil {
if err == prompt.ErrCanceled {
prompt.PanicCancel()
}
return nil, err
}
if optional && answer == "s" {
fmt.Println()
color.Cyan("Skipping module kind '%v'", kind)
return nil, nil
}
// Parse the index and return the associated module.
i, err := strconv.Atoi(answer)
if err == nil {
if 0 < i && i <= len(modules) {
return modules[i-1], nil
}
}
// In case we failed to parse the index or something, run the dialog again.
color.Yellow("Not a valid choice, please try again!")
}
}
func RunRecursively(cmd CliCommand) {
t := time.Now()
wg := new(sync.WaitGroup)
pathChan := make(chan vcsPath)
count := 0
go findRepositories(".", pathChan)
for p := range pathChan {
vcsCmd := cmd.GetVcsCommand(p.Sign)
if vcsCmd != nil {
wg.Add(1)
go execVcsCmd(vcsCmd, p.Path, wg)
count++
}
}
wg.Wait()
color.Cyan("Done \"%s\" command for %d repos in %s\n\n", cmd.Name, count, time.Since(t))
}
func main() {
flag.Parse()
if *sitemapURL == "" {
fmt.Println("-sitemap に sitemap.xml/.xml.gz のURLを指定してください")
return
}
smap, err := sitemap.Get(*sitemapURL)
if err != nil {
fmt.Println(err)
}
for _, URL := range smap.URL {
time.Sleep(time.Second)
resp, err := http.Get(URL.Loc)
if err != nil {
fmt.Println(err)
continue
}
defer resp.Body.Close()
switch statusType(resp.StatusCode) {
case 100:
color.Cyan(resp.Status + " " + URL.Loc)
case 200:
color.Green(resp.Status + " " + URL.Loc)
case 300:
color.Magenta(resp.Status + " " + URL.Loc)
case 400:
color.Red(resp.Status + " " + URL.Loc)
case 500:
color.Yellow(resp.Status + " " + URL.Loc)
default:
color.White(resp.Status + " " + URL.Loc)
}
}
}
func colorLineDiff(a, b string) {
aLines := strings.Split(a, "\n")
bLines := strings.Split(b, "\n")
fmt.Print("Overlapping portion of reassembled TCP Stream:\n")
for i := 0; i < len(aLines); i++ {
if aLines[i] == bLines[i] {
color.Blue(aLines[i])
} else {
color.Green(aLines[i])
}
}
fmt.Print("Injection packet whose contents did not coalesce into the TCP Stream:\n")
for i := 0; i < len(aLines); i++ {
if aLines[i] == bLines[i] {
color.Cyan(bLines[i])
} else {
color.Red(bLines[i])
}
}
}
func printAWS(v *vaulted.Vault, show bool) {
color.Cyan("\nAWS Key:")
if v.AWSKey != nil {
green.Printf(" Key ID: ")
fmt.Printf("%s\n", v.AWSKey.ID)
green.Printf(" Secret: ")
if !show {
fmt.Printf("%s\n", "<hidden>")
} else {
fmt.Printf("%s\n", v.AWSKey.Secret)
}
if v.AWSKey.MFA != "" {
green.Printf(" MFA: ")
fmt.Printf("%s\n", v.AWSKey.MFA)
}
if v.AWSKey.Role != "" {
green.Printf(" Role: ")
fmt.Printf("%s\n", v.AWSKey.Role)
}
} else {
print(" [Empty]")
}
}
// Build listens watch events from Watcher and sends messages to Runner
// when new changes are built.
func (b *Builder) Build(p *Params) {
go b.registerSignalHandler()
go func() {
// used for triggering the first build
b.watcher.update <- struct{}{}
}()
for range b.watcher.Wait() {
fileName := p.generateBinaryName()
pkg := p.packagePath()
log.Println("build started")
color.Cyan("Building %s...\n", pkg)
// build package
cmd, err := runCommand("go", "build", "-o", fileName, pkg)
if err != nil {
log.Fatalf("Could not run 'go build' command: %s", err)
continue
}
if err := cmd.Wait(); err != nil {
if err := interpretError(err); err != nil {
color.Red("An error occurred while building: %s", err)
} else {
color.Red("A build error occurred. Please update your code...")
}
continue
}
log.Println("build completed")
// and start the new process
b.runner.restart(fileName)
}
}
func main() {
username := ""
password := ""
language := "English"
quality := "1080p"
trim := ""
daisukiIntroTrim := false
aniplexIntroTrim := false
sunriseIntroTrim := false
app := cli.NewApp()
app.Name = "anirip"
app.Author = "Steven Wolfe"
app.Email = "*****@*****.**"
app.Version = "v1.4.0(7/7/2016)"
app.Usage = "Crunchyroll/Daisuki show ripper CLI"
color.Cyan(app.Name + " " + app.Version + " - by " + app.Author + " <" + app.Email + ">\n")
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "lang, l",
Value: "english",
Usage: "desired subtitle language",
Destination: &language,
},
cli.StringFlag{
Name: "quality, q",
Value: "1080p",
Usage: "desired video quality",
Destination: &quality,
},
cli.StringFlag{
Name: "trim, t",
Value: "",
Usage: "desired intros to be trimmed off of final video",
Destination: &trim,
},
}
app.Commands = []cli.Command{
{
Name: "login",
Aliases: []string{"l"},
Usage: "creates and stores cookies for a stream provider",
Flags: []cli.Flag{
cli.StringFlag{
Name: "user, u",
Value: "myusername",
Usage: "premium username used to access video stream",
Destination: &username,
},
cli.StringFlag{
Name: "pass, p",
Value: "mypassword",
Usage: "premium password used to access video stream",
Destination: &password,
},
},
Action: func(c *cli.Context) error {
// Gets the provider name from the cli argument
provider := ""
if c.NArg() > 0 {
provider = c.Args()[0]
} else {
color.Red("[anirip] No provider given...")
return anirip.Error{Message: "No provider given"}
}
// Creates session with cookies to store in file
var session anirip.Session
if strings.Contains(provider, "crunchyroll") {
color.Cyan("[anirip] Logging to CrunchyRoll as " + username + "...")
session = new(crunchyroll.CrunchyrollSession)
} else if strings.Contains(provider, "daisuki") {
color.Cyan("[anirip] Logging to Daisuki as " + username + "...")
session = new(daisuki.DaisukiSession)
} else {
color.Red("[anirip] The given provider is not supported.")
return anirip.Error{Message: "The given provider is not supported"}
}
// Performs the login procedure, storing the login information to file
if err := session.Login(username, password, tempDir); err != nil {
color.Red("[anirip] " + err.Error())
return anirip.Error{Message: "Unable to login to provider", Err: err}
}
color.Green("[anirip] Successfully logged in... Cookies saved to " + tempDir)
return nil
},
},
{
Name: "clear",
Aliases: []string{"c"},
Usage: "erases the temporary directory used for cookies and temp files",
Action: func(c *cli.Context) error {
// Attempts to erase the temporary directory
if err := os.RemoveAll(tempDir); err != nil {
color.Red("[anirip] There was an error erasing the temporary directory : " + err.Error())
return anirip.Error{Message: "There was an error erasing the temporary directory", Err: err}
}
color.Green("[anirip] Successfully erased the temporary directory " + tempDir)
return nil
},
},
}
app.Action = func(c *cli.Context) error {
if c.NArg() == 0 {
color.Red("[anirip] No show URLs provided.")
return anirip.Error{Message: "No show URLs provided"}
}
for _, showURL := range c.Args() {
// Parses the URL so we can accurately judge the provider based on the host
url, err := url.Parse(showURL)
if err != nil {
color.Red("[anirip] There was an error parsing the URL you entered.\n")
return anirip.Error{Message: "There was an error parsing the URL you entered"}
}
// Creates the authentication & show objects for the provider we're ripping from
var session anirip.Session
var show anirip.Show
if strings.Contains(strings.ToLower(url.Host), "crunchyroll") {
show = new(crunchyroll.CrunchyrollShow)
session = new(crunchyroll.CrunchyrollSession)
} else if strings.Contains(strings.ToLower(url.Host), "daisuki") {
show = new(daisuki.DaisukiShow)
session = new(daisuki.DaisukiSession)
} else {
color.Red("[anirip] The URL provided is not supported.")
return anirip.Error{Message: "The URL provided is not supported"}
}
// Performs the generic login procedure
if err = session.Login(username, password, tempDir); err != nil {
color.Red("[anirip] " + err.Error())
return anirip.Error{Message: "Unable to login to provider", Err: err}
}
// Attempts to scrape the shows metadata/information
color.White("[anirip] Getting a list of episodes for the show...")
if err = show.ScrapeEpisodes(showURL, session.GetCookies()); err != nil {
color.Red("[anirip] " + err.Error())
return anirip.Error{Message: "Unable to get episodes", Err: err}
}
// Sets the boolean values for what intros we would like to trim
if strings.Contains(strings.ToLower(trim), "daisuki") {
daisukiIntroTrim = true
}
if strings.Contains(strings.ToLower(trim), "aniplex") {
daisukiIntroTrim = true
}
if strings.Contains(strings.ToLower(trim), "sunrise") {
daisukiIntroTrim = true
}
seasonMap := map[int]string{
0: "Specials",
1: "Season One",
2: "Season Two",
3: "Season Three",
4: "Season Four",
5: "Season Five",
6: "Season Six",
7: "Season Seven",
8: "Season Eight",
9: "Season Nine",
10: "Season Ten",
}
os.Mkdir(show.GetTitle(), 0777)
for _, season := range show.GetSeasons() {
os.Mkdir(show.GetTitle()+string(os.PathSeparator)+seasonMap[season.GetNumber()], 0777)
for _, episode := range season.GetEpisodes() {
color.White("[anirip] Getting Episode Info...\n")
if err = episode.GetEpisodeInfo(quality, session.GetCookies()); err != nil {
color.Red("[anirip] " + err.Error())
continue
}
// Checks to see if the episode already exists, in which case we continue to the next
_, err = os.Stat(show.GetTitle() + string(os.PathSeparator) + seasonMap[season.GetNumber()] + string(os.PathSeparator) + episode.GetFileName() + ".mkv")
if err == nil {
color.Green("[anirip] " + episode.GetFileName() + ".mkv has already been downloaded successfully..." + "\n")
continue
}
subOffset := 0
color.Cyan("[anirip] Downloading " + episode.GetFileName() + "\n")
// Downloads full MKV video from stream provider
color.White("[anirip] Downloading video...\n")
if err := episode.DownloadEpisode(quality, tempDir, session.GetCookies()); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
// Trims down the downloaded MKV if the user wants to trim a Daisuki intro
if daisukiIntroTrim {
subOffset = subOffset + daisukiIntroLength
color.White("[anirip] Trimming off Daisuki Intro - " + strconv.Itoa(daisukiIntroLength) + "ms\n")
if err := trimMKV(daisukiIntroLength, tempDir); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
}
// Trims down the downloaded MKV if the user wants to trim an Aniplex intro
if aniplexIntroTrim {
subOffset = subOffset + aniplexIntroLength
color.White("[anirip] Trimming off Aniplex Intro - " + strconv.Itoa(aniplexIntroLength) + "ms\n")
if err := trimMKV(aniplexIntroLength, tempDir); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
}
// Trims down the downloaded MKV if the user wants to trim a Sunrise intro
if sunriseIntroTrim {
subOffset = subOffset + sunriseIntroLength
color.White("[anirip] Trimming off Sunrise Intro - " + strconv.Itoa(sunriseIntroLength) + "ms\n")
if err := trimMKV(sunriseIntroLength, tempDir); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
}
// Downloads the subtitles to .ass format and
// offsets their times by the passed provided interval
color.White("[anirip] Downloading subtitles with a total offset of " + strconv.Itoa(subOffset) + "ms...\n")
subtitleLang, err := episode.DownloadSubtitles(language, subOffset, tempDir, session.GetCookies())
if err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
// Attempts to merge the downloaded subtitles into the video strea
color.White("[anirip] Merging subtitles into mkv container...\n")
if err := mergeSubtitles("jpn", subtitleLang, tempDir); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
// Cleans the MKVs metadata for better reading by clients
color.White("[anirip] Cleaning MKV...\n")
if err := cleanMKV(tempDir); err != nil {
color.Red("[anirip] " + err.Error() + "\n")
continue
}
// Moves the episode to the appropriate season sub-directory
if err := anirip.Rename(tempDir+string(os.PathSeparator)+"episode.mkv",
show.GetTitle()+string(os.PathSeparator)+seasonMap[season.GetNumber()]+string(os.PathSeparator)+episode.GetFileName()+".mkv", 10); err != nil {
color.Red(err.Error() + "\n\n")
}
color.Green("[anirip] Downloading and merging completed successfully.\n")
}
}
color.Cyan("[anirip] Completed processing episodes for " + show.GetTitle() + "\n")
}
return nil
}
app.Run(os.Args)
}
func (j SubjectsImport) Run() {
start := time.Now()
fmt.Println("------------------------------")
fmt.Printf("| Starting import at %s\n", start.Format("2006-01-02 15:04:05.000"))
db := controllers.Gdb
db.LogMode(false)
file := OpenExcelFile("/home/kolan/Documents/ONR_FITIS.xlsx")
fmt.Println("------------------------------")
rowCount := 0
successCount := 0
alreadyExist := 0
for _, row := range file.Sheets[1].Rows[10:] {
var subject models.Subjects
re := regexp.MustCompile("[^\\S]+")
re2 := regexp.MustCompile("([^\x00-\x7F])i")
re3 := regexp.MustCompile("i([^\x00-\x7F])")
subjectName := strings.TrimSpace(row.Cells[1].Value)
subjectName = re.ReplaceAllString(subjectName, " ")
subjectName = re2.ReplaceAllString(subjectName, "${1}і")
subjectName = re3.ReplaceAllString(subjectName, "i${1}")
subject.Subject = subjectName
result := db.Where(&subject).First(&subject)
if result.Error != nil {
if result.RecordNotFound() {
db.NewRecord(subject)
err := db.Save(&subject).Error
if err != nil {
if regexp.MustCompile(`^Error 1062:`).MatchString(err.Error()) == true {
alreadyExist += 1
color.Cyan("| \"%s\" - is already exist", subjectName)
} else {
color.Red("| Saving error for - \"%s\"", subjectName)
}
} else {
successCount += 1
color.Green("| \"%s\" - added", subjectName)
}
}
} else {
alreadyExist += 1
color.Cyan("| \"%s\" - is already exist", subjectName)
}
rowCount += 1
}
elapsed := time.Since(start)
fmt.Println("------------------------------")
fmt.Printf("| Import finished at %s\n", time.Now().Format("2006-01-02 15:04:05.000"))
fmt.Printf("| Importing time %s\n", elapsed)
color.Blue("------------------------------")
color.Blue("| Subjects in file : %d", rowCount)
color.Blue("| Imported subjects : %d", successCount)
color.Blue("| Already exist subjects : %d", alreadyExist)
color.Blue("------------------------------")
}
func mustConfirmCommitBundle(userID int64, bundle *CommitBundle, args []string) *CommitBundle {
verbose := false
// create a websocket connection to the server
headers := make(http.Header)
url := "wss://" + Config.Host + "/v2/sockets/" + bundle.Problem.ProblemType + "/" + bundle.Commit.Action
socket, resp, err := websocket.DefaultDialer.Dial(url, headers)
if err != nil {
log.Printf("error dialing %s: %v", url, err)
if resp != nil && resp.Body != nil {
io.Copy(os.Stderr, resp.Body)
resp.Body.Close()
}
log.Fatalf("giving up")
}
defer socket.Close()
// form the initial request
req := &DaycareRequest{UserID: userID, CommitBundle: bundle}
if err := socket.WriteJSON(req); err != nil {
log.Fatalf("error writing request message: %v", err)
}
// start listening for events
for {
reply := new(DaycareResponse)
if err := socket.ReadJSON(reply); err != nil {
log.Fatalf("socket error reading event: %v", err)
break
}
switch {
case reply.Error != "":
log.Printf("server returned an error:")
log.Fatalf(" %s", reply.Error)
case reply.CommitBundle != nil:
return reply.CommitBundle
case reply.Event != nil:
if verbose {
switch reply.Event.Event {
case "exec":
color.Cyan("$ %s\n", strings.Join(reply.Event.ExecCommand, " "))
case "stdin":
color.Yellow("%s", reply.Event.StreamData)
case "stdout":
color.White("%s", reply.Event.StreamData)
case "stderr":
color.Red("%s", reply.Event.StreamData)
case "exit":
color.Cyan("exit: %s\n", reply.Event.ExitStatus)
case "error":
color.Red("Error: %s\n", reply.Event.Error)
}
}
default:
log.Fatalf("unexpected reply from server")
}
}
log.Fatalf("no commit returned from server")
return nil
}
func CommandCreate(cmd *cobra.Command, args []string) {
mustLoadConfig(cmd)
now := time.Now()
// find the directory
d := ""
switch len(args) {
case 0:
d = "."
case 1:
d = args[0]
default:
cmd.Help()
return
}
dir, err := filepath.Abs(d)
if err != nil {
log.Fatalf("error finding directory %q: %v", d, err)
}
// find the problem.cfg file
for {
path := filepath.Join(dir, ProblemConfigName)
if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
// try moving up a directory
old := dir
dir = filepath.Dir(dir)
if dir == old {
log.Fatalf("unable to find %s in %s or an ancestor directory", ProblemConfigName, d)
}
log.Printf("could not find %s in %s, trying %s", ProblemConfigName, old, dir)
continue
}
log.Fatalf("error searching for %s in %s: %v", ProblemConfigName, dir, err)
}
break
}
// parse problem.cfg
cfg := struct {
Problem struct {
Unique string
Note string
Type string
Tag []string
Option []string
}
Step map[string]*struct {
Note string
Weight float64
}
}{}
configPath := filepath.Join(dir, ProblemConfigName)
fmt.Printf("reading %s\n", configPath)
err = gcfg.ReadFileInto(&cfg, configPath)
if err != nil {
log.Fatalf("failed to parse %s: %v", configPath, err)
}
// create problem object
problem := &Problem{
Unique: cfg.Problem.Unique,
Note: cfg.Problem.Note,
ProblemType: cfg.Problem.Type,
Tags: cfg.Problem.Tag,
Options: cfg.Problem.Option,
CreatedAt: now,
UpdatedAt: now,
}
// start forming the problem bundle
unsigned := &ProblemBundle{
Problem: problem,
}
// check if this is an existing problem
existing := []*Problem{}
mustGetObject("/problems", map[string]string{"unique": problem.Unique}, &existing)
switch len(existing) {
case 0:
// new problem
if cmd.Flag("update").Value.String() == "true" {
log.Fatalf("you specified --update, but no existing problem with unique ID %q was found", problem.Unique)
}
// make sure the problem set with this unique name is free as well
existingSets := []*ProblemSet{}
mustGetObject("/problem_sets", map[string]string{"unique": problem.Unique}, &existingSets)
if len(existingSets) > 1 {
log.Fatalf("error: server found multiple problem sets with matching unique ID %q", problem.Unique)
}
if len(existingSets) != 0 {
log.Printf("problem set %d already exists with unique ID %q", existingSets[0].ID, existingSets[0].Unique)
log.Fatalf(" this would prevent creating a problem set containing just this problem with matching id")
}
log.Printf("this problem is new--no existing problem has the same unique ID")
case 1:
// update to existing problem
if cmd.Flag("update").Value.String() == "false" {
log.Fatalf("you did not specify --update, but a problem already exists with unique ID %q", problem.Unique)
}
log.Printf("unique ID is %s", problem.Unique)
log.Printf(" this is an update of problem %d (%q)", existing[0].ID, existing[0].Note)
problem.ID = existing[0].ID
problem.CreatedAt = existing[0].CreatedAt
default:
// server does not know what "unique" means
log.Fatalf("error: server found multiple problems with matching unique ID %q", problem.Unique)
}
// generate steps
whitelist := make(map[string]bool)
for i := int64(1); cfg.Step[strconv.FormatInt(i, 10)] != nil; i++ {
log.Printf("gathering step %d", i)
s := cfg.Step[strconv.FormatInt(i, 10)]
step := &ProblemStep{
Step: i,
Note: s.Note,
Weight: s.Weight,
Files: make(map[string]string),
}
commit := &Commit{
Step: i,
Action: "confirm",
Note: "author solution submitted via grind",
Files: make(map[string]string),
CreatedAt: now,
UpdatedAt: now,
}
// read files
starter, solution, root := make(map[string]string), make(map[string]string), make(map[string]string)
stepdir := filepath.Join(dir, strconv.FormatInt(i, 10))
err := filepath.Walk(stepdir, func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Fatalf("walk error for %s: %v", path, err)
}
if info.IsDir() {
return nil
}
relpath, err := filepath.Rel(stepdir, path)
if err != nil {
log.Fatalf("error finding relative path of %s: %v", path, err)
}
// load the file and add it to the appropriate place
contents, err := ioutil.ReadFile(path)
if err != nil {
log.Fatalf("error reading %s: %v", relpath, err)
}
// pick out solution/starter files
reldir, relfile := filepath.Split(relpath)
if reldir == "_solution/" && relfile != "" {
solution[relfile] = string(contents)
} else if reldir == "_starter/" && relfile != "" {
starter[relfile] = string(contents)
} else if reldir == "" && relfile != "" {
root[relfile] = string(contents)
} else {
step.Files[relpath] = string(contents)
}
return nil
})
if err != nil {
log.Fatalf("walk error for %s: %v", stepdir, err)
}
// find starter files and solution files
if len(solution) > 0 && len(starter) > 0 && len(root) > 0 {
log.Fatalf("found files in _starter, _solution, and root directory; unsure how to proceed")
}
if len(solution) > 0 {
// explicit solution
} else if len(root) > 0 {
// files in root directory must be the solution
solution = root
root = nil
} else {
log.Fatalf("no solution files found in _solution or root directory; problem must have a solution")
}
if len(starter) == 0 && root != nil {
starter = root
}
// copy the starter files into the step
for name, contents := range starter {
step.Files[name] = contents
// if the file exists as a starter in this or earlier steps, it can be part of the solution
whitelist[name] = true
}
// copy the solution files into the commit
for name, contents := range solution {
if whitelist[name] {
commit.Files[name] = contents
} else {
log.Printf("Warning: skipping solution file %q", name)
log.Printf(" because it is not in the starter file set of this or any previous step")
}
}
unsigned.ProblemSteps = append(unsigned.ProblemSteps, step)
unsigned.Commits = append(unsigned.Commits, commit)
log.Printf(" found %d problem definition file%s and %d solution file%s", len(step.Files), plural(len(step.Files)), len(commit.Files), plural(len(commit.Files)))
}
if len(unsigned.ProblemSteps) != len(cfg.Step) {
log.Fatalf("expected to find %d step%s, but only found %d", len(cfg.Step), plural(len(cfg.Step)), len(unsigned.ProblemSteps))
}
// get user ID
user := new(User)
mustGetObject("/users/me", nil, user)
// get the request validated and signed
signed := new(ProblemBundle)
mustPostObject("/problem_bundles/unconfirmed", nil, unsigned, signed)
// validate the commits one at a time
for n := 0; n < len(signed.ProblemSteps); n++ {
log.Printf("validating solution for step %d", n+1)
unvalidated := &CommitBundle{
Problem: signed.Problem,
ProblemSteps: signed.ProblemSteps,
ProblemSignature: signed.ProblemSignature,
Commit: signed.Commits[n],
CommitSignature: signed.CommitSignatures[n],
}
validated := mustConfirmCommitBundle(user.ID, unvalidated, nil)
log.Printf(" finished validating solution")
if validated.Commit.ReportCard == nil || validated.Commit.Score != 1.0 || !validated.Commit.ReportCard.Passed {
log.Printf(" solution for step %d failed: %s", n+1, validated.Commit.ReportCard.Note)
// play the transcript
for _, event := range validated.Commit.Transcript {
switch event.Event {
case "exec":
color.Cyan("$ %s\n", strings.Join(event.ExecCommand, " "))
case "stdin":
color.Yellow("%s", event.StreamData)
case "stdout":
color.White("%s", event.StreamData)
case "stderr":
color.Red("%s", event.StreamData)
case "exit":
color.Cyan("%s\n", event.ExitStatus)
case "error":
color.Red("Error: %s\n", event.Error)
}
}
log.Fatalf("please fix solution and try again")
}
signed.Problem = validated.Problem
signed.ProblemSteps = validated.ProblemSteps
signed.ProblemSignature = validated.ProblemSignature
signed.Commits[n] = validated.Commit
signed.CommitSignatures[n] = validated.CommitSignature
}
log.Printf("problem and solution confirmed successfully")
// save the problem
final := new(ProblemBundle)
if signed.Problem.ID == 0 {
mustPostObject("/problem_bundles/confirmed", nil, signed, final)
} else {
mustPutObject(fmt.Sprintf("/problem_bundles/%d", signed.Problem.ID), nil, signed, final)
}
log.Printf("problem %q saved and ready to use", final.Problem.Unique)
if signed.Problem.ID == 0 {
// create a matching problem set
// pause for a bit since the database seems to need to catch up
time.Sleep(time.Second)
// create a problem set with just this problem and the same unique name
psBundle := &ProblemSetBundle{
ProblemSet: &ProblemSet{
Unique: final.Problem.Unique,
Note: "set for single problem " + final.Problem.Unique + "\n" + final.Problem.Note,
Tags: final.Problem.Tags,
CreatedAt: now,
UpdatedAt: now,
},
ProblemIDs: []int64{final.Problem.ID},
Weights: []float64{1.0},
}
finalPSBundle := new(ProblemSetBundle)
mustPostObject("/problem_set_bundles", nil, psBundle, finalPSBundle)
log.Printf("problem set %q created and ready to use for this problem", finalPSBundle.ProblemSet.Unique)
}
}
func (j GroupsImport) Run() {
start := time.Now()
fmt.Println("------------------------------")
fmt.Printf("| Starting import at %s\n", start.Format("2006-01-02 15:04:05.000"))
db := controllers.Gdb
file := OpenExcelFile("/home/kolan/Documents/ONR_FITIS.xlsx")
fmt.Println("------------------------------")
rowCount := 0
successCount := 0
alreadyExist := 0
wrongYear := 0
wrongNumberOfStudents := 0
for _, row := range file.Sheets[1].Rows[10:] {
group := models.Groups{}
re := regexp.MustCompile("[^\\S]+")
re2 := regexp.MustCompile("([^\x00-\x7F])i")
re3 := regexp.MustCompile("i([^\x00-\x7F])")
groupYear, err := strconv.Atoi(strings.TrimSpace(row.Cells[7].Value))
if err != nil {
group.Year = 0
wrongYear += 1
} else {
group.Year = groupYear
}
groupName := strings.TrimSpace(row.Cells[27].Value)
groupName = re.ReplaceAllString(groupName, " ")
groupName = re2.ReplaceAllString(groupName, "${1}і")
groupName = re3.ReplaceAllString(groupName, "i${1}")
group.Name = groupName
groupStudents, err := strconv.Atoi(strings.TrimSpace(row.Cells[11].Value))
if err != nil {
group.NumOfStudents = 0
wrongNumberOfStudents += 1
} else {
group.NumOfStudents = groupStudents
}
group.FacultyId = 1
result := db.Where(&group).First(&group)
if result.Error != nil {
if result.RecordNotFound() {
db.NewRecord(group)
err = db.Save(&group).Error
if err != nil {
if regexp.MustCompile(`^Error 1062:`).MatchString(err.Error()) == true {
alreadyExist += 1
color.Cyan("| \"%s\" - is already exist", groupName)
} else {
color.Red("| Saving error for - \"%s\"", groupName)
}
} else {
successCount += 1
color.Green("| \"%s\" - added", groupName)
}
}
} else {
alreadyExist += 1
color.Cyan("| \"%s\" - is already exist", groupName)
}
rowCount += 1
}
elapsed := time.Since(start)
fmt.Println("------------------------------")
fmt.Printf("| Import finished at %s\n", time.Now().Format("2006-01-02 15:04:05.000"))
fmt.Printf("| Importing time %s\n", elapsed)
color.Blue("------------------------------------------")
color.Blue("| Groups in file : %d", rowCount)
color.Blue("| Imported groups : %d", successCount)
color.Blue("| Already exist groups : %d", alreadyExist)
color.Blue("| Groups without year : %d", wrongYear)
color.Blue("| Groups without students count : %d", wrongNumberOfStudents)
color.Blue("------------------------------------------")
}
func main() {
// Server Options
opts := Options{}
var showVersion bool
var debugAndTrace bool
var configFile string
// Parse flags
flag.IntVar(&opts.Port, "port", 0, "Port to listen on.")
flag.IntVar(&opts.Port, "p", 0, "Port to listen on.")
flag.StringVar(&opts.Host, "host", "", "Network host to listen on.")
flag.StringVar(&opts.Host, "h", "", "Network host to listen on.")
flag.StringVar(&opts.Host, "net", "", "Network host to listen on.")
flag.BoolVar(&opts.Debug, "D", false, "Enable Debug logging.")
flag.BoolVar(&opts.Debug, "debug", false, "Enable Debug logging.")
flag.BoolVar(&opts.Trace, "V", false, "Enable Trace logging.")
flag.BoolVar(&opts.Trace, "trace", false, "Enable Trace logging.")
flag.BoolVar(&debugAndTrace, "DV", false, "Enable Debug and Trace logging.")
flag.BoolVar(&opts.Logtime, "T", true, "Timestamp log entries.")
flag.BoolVar(&opts.Logtime, "logtime", true, "Timestamp log entries.")
flag.StringVar(&opts.Username, "user", "", "Username required for connection.")
flag.StringVar(&opts.Password, "pass", "", "Password required for connection.")
flag.StringVar(&opts.Authorization, "auth", "", "Authorization token required for connection.")
flag.StringVar(&configFile, "c", "", "Configuration file.")
flag.StringVar(&configFile, "config", "", "Configuration file.")
flag.StringVar(&opts.PidFile, "P", "", "File to store process pid.")
flag.StringVar(&opts.PidFile, "pid", "", "File to store process pid.")
flag.StringVar(&opts.LogFile, "l", "", "File to store logging output.")
flag.StringVar(&opts.LogFile, "log", "", "File to store logging output.")
flag.BoolVar(&showVersion, "version", false, "Print version information.")
flag.BoolVar(&showVersion, "v", false, "Print version information.")
flag.Usage = usage
flag.Parse()
// Show version and exit
if showVersion {
PrintServerAndExit()
}
// One flag can set multiple options.
if debugAndTrace {
opts.Trace, opts.Debug = true, true
}
// Process args looking for non-flag options,
// 'version' and 'help' only for now
for _, arg := range flag.Args() {
switch strings.ToLower(arg) {
case "version":
PrintServerAndExit()
case "help":
usage()
}
}
// Parse config
var cfg config.Config
cfg.Parse()
// MongoDb
db.InitMongo(cfg.MongoHost, cfg.MongoPort, cfg.MongoDatabase)
// MQTT
mqc := new(clients.MqttConn)
//Sub to everything comming on all channels of all devices
mqc.MqttSub()
// Serve HTTP
go servers.HttpServer(cfg)
// Print banner
color.Cyan(banner)
color.Cyan("Magic happens on port " + strconv.Itoa(cfg.HttpPort))
/** Keep main() runnig */
runtime.Goexit()
}