Beispiel #1
30
func messageListener(o *gomegle.Omegle, logger *log.Logger) {
	for {
		err := o.ShowTyping()
		if err != nil {
			logger.Print(err)
		}

		reader := bufio.NewReader(os.Stdin)
		text, err := reader.ReadString('\n')
		if err != nil {
			err = o.Disconnect()
			if err != nil {
				logger.Fatal(err)
			}
			fmt.Println("- Disconnected")
			ret := o.GetID()
			if ret != nil {
				logger.Fatal(ret)
			}
			continue
		}

		err = o.StopTyping()
		if err != nil {
			logger.Print(err)
		}

		err = o.SendMessage(text)
		if err != nil {
			logger.Fatal(err)
			continue
		}
	}
}
Beispiel #2
0
// DefaultFormat returns a middleware that logs http requests
// to the given logger using the default log format.
func DefaultFormat(l *log.Logger) httpmux.MiddlewareFunc {
	return func(next http.HandlerFunc) http.HandlerFunc {
		return func(w http.ResponseWriter, r *http.Request) {
			start := time.Now()
			rw := NewResponseWriter(w)
			next(rw, r)
			b := getBuffer()
			b.WriteString(r.Proto)
			b.Write([]byte(" "))
			b.WriteString(strconv.Itoa(rw.Code()))
			b.Write([]byte(" "))
			b.WriteString(r.Method)
			b.Write([]byte(" "))
			b.WriteString(r.URL.RequestURI())
			b.Write([]byte(" from "))
			b.WriteString(r.RemoteAddr)
			b.Write([]byte(" "))
			fmt.Fprintf(b, "%q", r.Header.Get("User-Agent"))
			b.Write([]byte(" "))
			b.WriteString(strconv.Itoa(rw.Bytes()))
			b.Write([]byte(" bytes in "))
			b.WriteString(time.Since(start).String())
			if err := httpmux.Context(r).Value(ErrorID); err != nil {
				fmt.Fprintf(b, " err: %v", err)
			}
			l.Print(b.String())
			putBuffer(b)
		}
	}
}
Beispiel #3
0
// Print calls Print on a logger or the default logger.
// Arguments are handled in the manner of fmt.Print.
func Print(l *log.Logger, v ...interface{}) {
	if l == nil {
		log.Print(v...)
	} else {
		l.Print(v...)
	}
}
Beispiel #4
0
func StartWorker(CacheInvalidation bool, WorkQueue chan File, log *log.Logger) {
	var err error
	for {
		select {
		case f := <-WorkQueue:
			startTime := time.Now().UTC()

			jobId := "b-" + randomString(5) + " "
			log.SetPrefix(jobId)

			log.Print("Batch process starting: " + f.Tag + ", " + f.Filename)
			// Simulate some processing time
			if f.MediaType() == "image" {
				err = f.GenerateImage(75, 75, true)
				if err != nil {
					log.Print(err)
				}
				err = f.GenerateImage(1140, 0, false)
				if err != nil {
					log.Print(err)
				}

				if CacheInvalidation {
					if err := f.Purge(); err != nil {
						log.Print(err)
					}
				}
			}
			finishTime := time.Now().UTC()
			elapsedTime := finishTime.Sub(startTime)
			log.Println("Completed in: " + elapsedTime.String())
		}
	}
}
Beispiel #5
0
func notify(config localConfig, hook hookEvent, ws, logDir string, notification grimNotification, logger *log.Logger) error {
	if hook.EventName != "push" && hook.EventName != "pull_request" {
		return nil
	}

	ghErr := setRefStatus(config.gitHubToken(), hook.Owner, hook.Repo, hook.StatusRef, notification.GithubRefStatus(), "", "")

	context := buildContext(hook, ws, logDir)
	message, color, err := notification.HipchatNotification(context, config)
	logger.Print(message)

	if config.hipChatToken() != "" && config.hipChatRoom() != "" {
		if err != nil {
			logger.Printf("Hipchat: Error while rendering message: %v", err)
			return err
		}

		err = sendMessageToRoom(config.hipChatToken(), config.hipChatRoom(), config.grimServerID(), message, color)
		if err != nil {
			logger.Printf("Hipchat: Error while sending message to room: %v", err)
			return err
		}
	} else {
		logger.Print("HipChat: config.hipChatToken and config.hitChatRoom not set")
	}

	return ghErr
}
func LoginHandler(w http.ResponseWriter, r *http.Request, session sessions.Session, log *log.Logger) string {
	c, err := config.ReadDefault("users.cfg")

	if err != nil {
		return "Can't login. Problems reading user and password."
	}

	username := r.FormValue("username")
	password := r.FormValue("password")

	allowedUsername, _ := c.RawStringDefault("user")
	allowedPassword, _ := c.RawStringDefault("password")

	if username == allowedUsername && password == allowedPassword {

		log.Print("User WAS logged in.")

		session.Set("username", username)
		session.Set("password", password)
		http.Redirect(w, r, "/home", http.StatusFound)
		return "OK"
	}

	log.Print("User wasn't logged in. User " + username + " and password " + password)

	http.Redirect(w, r, "/login", http.StatusFound)
	return "Username or password incorrect"
}
Beispiel #7
0
func addCategories(files []fileData, client *mwclient.Client, verbose *log.Logger, catFileLimit int32, allCategories map[string]bool, catCounts map[string]int32, stats *stats) {
	for i := range files {
		if files[i].processed {
			continue
		}
		// The cat size limit needs to be checked again, since adding
		// previous files in the batch may have pushed it over the
		// limit.
		if catFileLimit > 0 && catCounts[files[i].catMapped] >= catFileLimit {
			stats.populated++
			verbose.Print(files[i].title, "\n", "Already populated: ", files[i].catMapped)
		} else {
			// Identifying emtpy categories helps identify
			// when we are adding a file to a redirect page
			// for a renamed category.
			if catCounts[files[i].catMapped] == 0 {
				warn.Print(files[i].title, "\n", "Adding to empty ", files[i].catMapped)
				files[i].warning = "Added to empty category"
				stats.warnings++
			} else {
				verbose.Printf("%s\nAdding to %s (%d files)", files[i].title, files[i].catMapped, int(catCounts[files[i].catMapped]))
			}
			stats.edited++
			addCategory(files[i].title, files[i].catMapped, client)
			incCatCount(files[i].catMapped, catCounts)
		}
		files[i].processed = true
	}
}
Beispiel #8
0
// Determine if any of cats (a file's current categories) match either the
// Exif target category, any known target category, or any unknown category
// that's named like a target category.
func matchCategories(file *fileData, cats []string, mapped string, verbose *log.Logger, ignoreCurrentCats bool, allCategories map[string]bool, stats *stats) bool {
	result := false
	for _, cat := range cats {
		if mapped == cat {
			stats.inCat++
			verbose.Print(file.title, "\n", "Already in mapped: ", mapped)
			result = true
			break
		}
		if !ignoreCurrentCats {
			if allCategories[cat] {
				result = true
				stats.inCat++
				verbose.Print(file.title, "\n", "Already in known: ", cat)
				break
			}
			if strings.HasPrefix(cat, "Category:Taken ") || strings.HasPrefix(cat, "Category:Scanned ") {
				result = true
				warn.Print(file.title, "\n", "Already in unknown: ", cat)
				file.warning = "In unknown " + cat
				stats.warnings++
				break
			}
		}
	}
	return result
}
Beispiel #9
0
// createContainer initializes a struct needed to call docker.client.CreateContainer()
func createContainer(ctx *ExecContext, task *structs.Task, logger *log.Logger) docker.CreateContainerOptions {
	if task.Resources == nil {
		panic("task.Resources is nil and we can't constrain resource usage. We shouldn't have been able to schedule this in the first place.")
	}

	hostConfig := createHostConfig(task)
	logger.Printf("[DEBUG] driver.docker: using %d bytes memory for %s", hostConfig.Memory, task.Config["image"])
	logger.Printf("[DEBUG] driver.docker: using %d cpu shares for %s", hostConfig.CPUShares, task.Config["image"])

	// Setup port mapping (equivalent to -p on docker CLI). Ports must already be
	// exposed in the container.
	if len(task.Resources.Networks) == 0 {
		logger.Print("[WARN] driver.docker: No networks are available for port mapping")
	} else {
		network := task.Resources.Networks[0]
		dockerPorts := map[docker.Port][]docker.PortBinding{}

		for _, port := range network.ListStaticPorts() {
			dockerPorts[docker.Port(strconv.Itoa(port)+"/tcp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
			dockerPorts[docker.Port(strconv.Itoa(port)+"/udp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
			logger.Printf("[DEBUG] driver.docker: allocated port %s:%d -> %d (static) %s\n", network.IP, port, port)
		}

		for label, port := range network.MapDynamicPorts() {
			// If the label is numeric we expect that there is a service
			// listening on that port inside the container. In this case we'll
			// setup a mapping from our random host port to the label port.
			//
			// Otherwise we'll setup a direct 1:1 mapping from the host port to
			// the container, and assume that the process inside will read the
			// environment variable and bind to the correct port.
			if _, err := strconv.Atoi(label); err == nil {
				dockerPorts[docker.Port(label+"/tcp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
				dockerPorts[docker.Port(label+"/udp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
				logger.Printf("[DEBUG] driver.docker: allocated port %s:%d -> %s (mapped)", network.IP, port, label)
			} else {
				dockerPorts[docker.Port(strconv.Itoa(port)+"/tcp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
				dockerPorts[docker.Port(strconv.Itoa(port)+"/udp")] = []docker.PortBinding{docker.PortBinding{HostIP: network.IP, HostPort: strconv.Itoa(port)}}
				logger.Printf("[DEBUG] driver.docker: allocated port %s:%d -> %d for label %s\n", network.IP, port, port, label)
			}
		}
		hostConfig.PortBindings = dockerPorts
	}

	config := &docker.Config{
		Env:   TaskEnvironmentVariables(ctx, task).List(),
		Image: task.Config["image"],
	}

	// If the user specified a custom command to run, we'll inject it here.
	if command, ok := task.Config["command"]; ok {
		config.Cmd = strings.Split(command, " ")
	}

	return docker.CreateContainerOptions{
		Config:     config,
		HostConfig: hostConfig,
	}
}
func AddServiceEndpointLoggingMiddleware(logger log.Logger) endpoint.Middleware {
	return func(next endpoint.Endpoint) endpoint.Endpoint {
		return func(ctx context.Context, request interface{}) (interface{}, error) {
			logger.Print("calling endpoint")
			defer logger.Print("called endpoint")
			return next(ctx, request)
		}
	}
}
Beispiel #11
0
// Returns a new server with the given name and empty cache
// It serves the files in the directory given when is created
func NewWebServer(dir string, logger log.Logger) *Server {

	server := &Server{}
	server.pwd = dir
	server.cache = NewCache()
	// server.sessions
	server.logger = logger

	logger.Print("Server created")
	return server
}
Beispiel #12
0
func runTriggers(triggers []*triggers.Trigger, action string,
	logger *log.Logger) bool {
	hadFailures := false
	needRestart := false
	logPrefix := ""
	if *disableTriggers {
		logPrefix = "Disabled: "
	}
	// For "start" action, if there is a reboot trigger, just do that one.
	if action == "start" {
		for _, trigger := range triggers {
			if trigger.Service == "reboot" {
				logger.Print(logPrefix, "Rebooting")
				if *disableTriggers {
					return hadFailures
				}
				if !runCommand(logger, "reboot") {
					hadFailures = true
				}
				return hadFailures
			}
		}
	}
	ppid := fmt.Sprint(os.Getppid())
	for _, trigger := range triggers {
		if trigger.Service == "reboot" && action == "stop" {
			continue
		}
		if trigger.Service == "subd" {
			// Never kill myself, just restart.
			if action == "start" {
				needRestart = true
			}
			continue
		}
		logger.Printf("%sAction: service %s %s\n",
			logPrefix, trigger.Service, action)
		if *disableTriggers {
			continue
		}
		if !runCommand(logger,
			"run-in-mntns", ppid, "service", trigger.Service, action) {
			hadFailures = true
		}
	}
	if needRestart {
		logger.Printf("%sAction: service subd restart\n", logPrefix)
		if !runCommand(logger,
			"run-in-mntns", ppid, "service", "subd", "restart") {
			hadFailures = true
		}
	}
	return hadFailures
}
Beispiel #13
0
func fwdSignal(logger *log.Logger, command *exec.Cmd, sig os.Signal) {
	switch sig {
	case os.Interrupt, syscall.SIGTERM, syscall.SIGCHLD:
		return
	}
	if err := command.Process.Signal(sig); err != nil {
		logger.Printf("glock: Error while sending signal %s: %s", sig, err.Error())
	}
	if sig == syscall.SIGTSTP {
		logger.Print("glock: SIGTSTP sent to child process, but will continue to send heartbeats for the locks")
	}
}
Beispiel #14
0
// ApacheCommonFormat returns a middleware that logs http requests
// to the given logger using the Apache Common log format.
func ApacheCommonFormat(l *log.Logger) httpmux.MiddlewareFunc {
	return func(next http.HandlerFunc) http.HandlerFunc {
		return func(w http.ResponseWriter, r *http.Request) {
			start := time.Now()
			rw := NewResponseWriter(w)
			next(rw, r)
			b := apacheCommonLog(rw, r, start)
			l.Print(b.String())
			putBuffer(b)
		}
	}
}
Beispiel #15
0
func saveToFile(data com.MasterData, masterLogger log.Logger) {
	file, err := os.Create("backupData.json")
	if err != nil {
		masterLogger.Print(err)
	}
	buf, err := json.Marshal(data)
	if err != nil {
		masterLogger.Print(err)
	}
	file.Write(buf)
	file.Close()
}
Beispiel #16
0
// DumpClientEvents reads client to server events from r, and dumps them as
// text to l.
func DumpClientEvents(r io.Reader, l *log.Logger, maxFrameLen int) error {
	var ger artproto.ClientEventReader
	ger.Init(r, maxFrameLen)
	var ev ClientEventsDumper
	ev.Init(l)

	for ger.FramingErr == nil {
		if err := ger.Next(&ev, nil); err != nil {
			l.Print("Error: ", err)
		}
	}
	return ger.FramingErr
}
Beispiel #17
0
// DumpServerEvents reads server to client events from r, and dumps them as
// text to l. valueIDFn if not nil, is called with values from object updates.
func DumpServerEvents(r io.Reader, valueIDFn ValueIDFn, l *log.Logger, maxFrameLen int) error {
	var ger artproto.ServerEventReader
	ger.Init(r, maxFrameLen)
	var ev ServerEventsDumper
	ev.Init(l, valueIDFn)

	for ger.FramingErr == nil {
		if err := ger.Next(&ev, nil); err != nil {
			l.Print("Error: ", err)
		}
	}
	return ger.FramingErr
}
func (lw *LogWriter) logTrace(traceId string, logString string) bool {
	var logger *log.Logger
	lw.traceMu.RLock()
	tl := lw.traceFileMap[traceId]
	lw.traceMu.RUnlock()
	if tl == nil {
		filePath := getDefaultPath() + pathSeparator() + "trace_" + traceId + ".log"
		file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
		if err != nil {
			lw.logger.Print("Logger: Unable to create trace file %s, Error %s", filePath, err.Error())
			return false
		}
		logger = log.New(file, "", log.Lmicroseconds)
		fileLockPath := getDefaultPath() + pathSeparator() + "trace_" + traceId + ".lock"
		fl, _ := lockfile.New(fileLockPath)
		tl = &TraceLogger{file: file, logger: logger, counter: lw.logCounter, fileLock: fl}
		lw.traceMu.Lock()
		lw.traceFileMap[traceId] = tl
		lw.traceMu.Unlock()
		if lw.cleanerRunning == false {
			// restart the cleaner
			go cleanupMap(lw)
		}
	} else {
		logger = tl.(*TraceLogger).logger
		tl.(*TraceLogger).counter = lw.logCounter
	}

	var locked bool
	err := tl.(*TraceLogger).fileLock.TryLock()
	if err != nil {
		// busy wait a few times before giving up
		for i := 0; i < MAX_LOCK_RETRY; i++ {
			time.Sleep(10 * time.Millisecond)
			err = tl.(*TraceLogger).fileLock.TryLock()
			if err == nil {
				locked = true
				break
			}
		}
		// unable to acquire lock
		if locked == false {
			return false
		}
	}
	defer tl.(*TraceLogger).fileLock.Unlock()

	logger.Print(logString)
	return true
}
Beispiel #19
0
func UDPInit(master bool, sendChannel, receiveChannel chan UDPMessage, networkLogger log.Logger) {
	var localPort, broadcastPort string
	if master {
		networkLogger.Print("Connecting as master")
		localPort = masterPort
		broadcastPort = slavePort
	} else {
		networkLogger.Print("Connecting as slave")
		localPort = slavePort
		broadcastPort = masterPort
	}

	laddr, err := net.ResolveUDPAddr("udp", ":"+localPort)
	if err != nil {
		networkLogger.Print(err)
	}

	conn, err := net.ListenUDP("udp", laddr)
	if err != nil {
		networkLogger.Print("Failed to connect")
		return
	}
	defer conn.Close()

	go listenServer(conn, receiveChannel, networkLogger)
	broadcastServer(conn, broadcastPort, sendChannel, networkLogger)
}
Beispiel #20
0
func logMaybeMap(l *log.Logger, args ...interface{}) {
	msg, mok := args[0].(string)
	fields, fok := args[1].(map[string]interface{})
	if !(mok && fok) {
		l.Println(args)
		return
	}
	msg = msg + ": "
	for k, v := range fields {
		msg = fmt.Sprintf("%s %s = %v", msg, k, v)
	}
	l.Print(msg)
	return
}
Beispiel #21
0
func logWithLongFile(l *log.Logger, format string, v ...interface{}) {
	_, file, line, _ := runtime.Caller(2)

	// Shorten the path.
	// From
	// /builddir/build/BUILD/heketi-3f4a5b1b6edff87232e8b24533c53b4151ebd9c7/src/github.com/heketi/heketi/apps/glusterfs/volume_entry.go
	// to
	// src/github.com/heketi/heketi/apps/glusterfs/volume_entry.go
	i := strings.Index(file, "/src/")
	if i == -1 {
		i = 0
	}

	l.Print(fmt.Sprintf("%v:%v: ", file[i:], line) +
		fmt.Sprintf(format, v...))
}
Beispiel #22
0
func displaySummary(logger *log.Logger, start time.Time, files, rawLines, validLines int) {
	defer T.Un(T.Trace(""))

	delta := time.Since(start)
	summary := fmt.Sprintf("Parsed %s/%s(%.4f%s) lines in %d files within %s [%.1f lines per second]\n",
		size.Comma(int64(validLines)),
		size.Comma(int64(rawLines)),
		100*float64(validLines)/float64(rawLines),
		"%%",
		files,
		delta,
		float64(rawLines)/delta.Seconds())
	// render to both log and stderr
	logger.Print(summary)
	fmt.Fprintf(os.Stderr, summary)
}
Beispiel #23
0
// ApacheCombinedFormat returns a middleware that logs http requests
// to the given logger using the Apache Combined log format.
func ApacheCombinedFormat(l *log.Logger) httpmux.MiddlewareFunc {
	return func(next http.HandlerFunc) http.HandlerFunc {
		return func(w http.ResponseWriter, r *http.Request) {
			start := time.Now()
			rw := NewResponseWriter(w)
			next(rw, r)
			b := apacheCommonLog(rw, r, start)
			b.Write([]byte(" "))
			fmt.Fprintf(b, "%q %q",
				r.Header.Get("Referer"),
				r.Header.Get("User-Agent"),
			)
			l.Print(b.String())
			putBuffer(b)
		}
	}
}
Beispiel #24
0
// checkPkgPath checks the directories of compiled packages taking an import or
// filesystem path.
// Returns "pkgTowatch", the absolute path of compiled packages; and "pkgFiles",
// for systems without kernel subsystem like inotify.
func checkPkgPath(path []string, logg *log.Logger) (pkgTowatch, pkgFiles []string, err error) {
	var hasError bool
	pkgTowatch = make([]string, len(path))

	for i, p := range path {
		pkg, err := build.Import(p, build.Default.GOPATH, build.AllowBinary)
		/*if err != nil {
			logg.Print("FAIL! checkPkgPath: at getting directory: ", err)
			hasError = true
			continue
		}*/
		if pkg.IsCommand() {
			logg.Print("FAIL! no package: ", p)
			hasError = true
			continue
		}

		pkgPath := filepath.Join(pkg.PkgRoot, runtime.GOOS+"_"+runtime.GOARCH, pkg.ImportPath)
		_, err = os.Stat(pkgPath + _EXT_COMPILED)

		if err != nil && os.IsNotExist(err) {
			// Get compiled packages
			switch files, err := filepath.Glob(filepath.Join(pkgPath, "*"+_EXT_COMPILED)); {
			case err != nil:
				logg.Print("FAIL! checkPkgPath: at getting compiled packages: ", err)
				hasError = true
			case len(files) == 0:
				logg.Printf("FAIL! checkPkgPath: no compiled packages in directory %q", p)
				hasError = true
			case !USE_KERNEL: // there is to get all files to watching
				pkgFiles = append(pkgFiles, files...)
			}
		} else {
			pkgPath += _EXT_COMPILED
		}

		if !hasError {
			pkgTowatch[i] = pkgPath
		}
	}

	if hasError {
		return nil, nil, errWatcher
	}
	return
}
Beispiel #25
0
// Process files where the category is missing or already populated.
func filterCatLimit(files []fileData, client *mwclient.Client, verbose *log.Logger, catFileLimit int32, catCounts map[string]int32, stats *stats) {
	for i := range files {
		if !files[i].processed && files[i].catMapped != "" {
			count, found := catCounts[files[i].catMapped]
			if !found {
				warn.Print(files[i].title, "\n", "Mapped category doesn't exist: ", files[i].catMapped)
				files[i].warning = files[i].catMapped + " doesn't exist"
				stats.warnings++
				files[i].processed = true
				continue
			}
			if catFileLimit > 0 && count >= catFileLimit {
				stats.populated++
				verbose.Print(files[i].title, "\n", "Already populated: ", files[i].catMapped)
				files[i].processed = true
				continue
			}
		}
	}
}
Beispiel #26
0
// sysWatcher starts the watcher.
func sysWatcher(cmdTocompile string, pkgTowatch []string, logg *log.Logger) (*pkgWatcher, error) {
	watcher, err := inotify.NewWatcher()
	if err != nil {
		logg.Print("FAIL! sysWatcher: ", err)
		return nil, errWatcher
	}

	ok := true
	// Watch every path
	for _, path := range pkgTowatch {
		if err = watcher.AddWatch(path, inotify.IN_MODIFY); err != nil {
			logg.Print("FAIL! sysWatcher: ", err)
			ok = false
		}
	}

	if !ok {
		return nil, errWatcher
	}
	return &pkgWatcher{watcher, logg, cmdTocompile}, nil
}
Beispiel #27
0
func InitMaster(events com.MasterEvent,
	initialOrders []order.Order,
	initialSlaves map[network.IP]com.Slave,
	masterLogger log.Logger) {

	backupDeadlineTimer := time.NewTimer(backupDeadline)
	selfAsBackup := false

	orders := initialOrders
	slaves := initialSlaves

	masterLogger.Print("Waiting for backup")
	for {
		select {
		case <-backupDeadlineTimer.C:
			masterLogger.Print("Not contacted by external slave within deadline. Can now use self as backup.")
			selfAsBackup = true

		case message := <-events.FromSlaves:
			_, err := com.DecodeSlaveMessage(message.Data)
			if err != nil {
				break
			}

			if (selfAsBackup && message.Address == myIP) || message.Address != myIP {
				orders, slaves = masterLoop(events, message.Address, orders, slaves, masterLogger)
				masterLogger.Print("Waiting for new backup")
				backupDeadlineTimer.Reset(backupDeadline)
			}
		}
	}
}
/* Sort every line which arrives through reader onto one of the channels from
 * s, depending on the line's content. */
func (s stream_channels) sort_stream(conn *net.Conn, logger *log.Logger) {
	reader := bufio.NewReader(*conn)

	for {
		str, err := reader.ReadString('\n')
		if err != nil {
			//something went wrong, stop sorting
			return
		}

		if len(str) > 0 {
			if strings.HasPrefix(str, ">") {
				/* end of a shell command execution, create clean newline */
				s.rcv_other <- ">\n"
				/* remove > from str*/
				str = strings.TrimPrefix(str, "> ")
			}

			if str == "EOF" {
				// TODO properly
				fmt.Println("found an eof")
				break
			}

			/* If there's something left, log, check line content and sort */
			if len(str) > 0 {
				logger.Print(str)
				switch get_content_type(str) {
				case CONTENT_TYPE_JSON:
					/* this line contains a JSON */
					s.rcv_json <- str
				case CONTENT_TYPE_OTHER:
					/* this line contains something else */
					s.rcv_other <- str
				}
			}
		}
	}
}
Beispiel #29
0
func StartWorker(WorkQueue chan File, log *log.Logger) {
	for {
		select {
		case f := <-WorkQueue:
			startTime := time.Now().UTC()

			jobId := "b-" + randomString(5) + " "
			log.SetPrefix(jobId)

			log.Print("Batch process starting: " + f.Tag + ", " + f.Filename)
			// Simulate some processing time
			if f.MediaType() == "image" {
				err := f.GenerateThumbnail()
				if err != nil {
					log.Print(err)
				}
			}
			finishTime := time.Now().UTC()
			elapsedTime := finishTime.Sub(startTime)
			log.Println("Completed in: " + elapsedTime.String())
		}
	}
}
Beispiel #30
0
// Determine Commons category from imageinfo (Exif) data, if possible.
func mapCategories(files []fileData, verbose *log.Logger, categoryMap map[string]string, catRegex []catRegex, stats *stats) {
	for i := range files {
		var err error
		files[i].title, err = files[i].pageObj.GetString("title")
		if err != nil {
			panic(err)
		}
		imageinfo, err := files[i].pageObj.GetObjectArray("imageinfo")
		if err == nil {
			files[i].make, files[i].model = extractCamera(imageinfo[0])
		}
		if err != nil || (files[i].make == "" && files[i].model == "") {
			verbose.Print(files[i].title, "\n", "No camera details in Exif")
			files[i].processed = true
			continue
		}
		stats.withCamera++
		// Category mapping: first try the simple map for an exact
		// match (which is fast), when try each regex match in turn.
		// If mapping fails, processing continues with blank catMapped
		// to determine file's current categories before displaying a
		// warning.
		key := files[i].make + files[i].model
		var found bool
		files[i].catMapped, found = categoryMap[key]
		if !found {
			files[i].catMapped = applyRegex(key, catRegex)
		}

		if files[i].catMapped == "Category:CanonS100 (special case)" {
			files[i].catMapped = mapCanonS100(imageinfo)
		} else if files[i].catMapped == "Category:CanonS110 (special case)" {
			files[i].catMapped = mapCanonS110(imageinfo)
		}
	}
}