Exemplo n.º 1
0
// redirect go goes from here
func Redirect(params martini.Params, r render.Render, pool *redis.Pool) {
	entity := &Entity{}
	entity.Token = params["token"]
	err := entity.Retrieve(pool)
	if err != nil {
		syslog.Critf("Error: Token not found %s", params["token"])
		r.HTML(404, "404", nil)
	} else {
		syslog.Critf("Redirect from %s to %s", Get("lilliput.domain", "").(string)+params["token"], entity.Url)
		r.Redirect(entity.Url, 301)
	}
}
Exemplo n.º 2
0
func main() {

	syslog.Openlog("cinefade", syslog.LOG_PID, syslog.LOG_USER)

	var action string
	flag.StringVar(&action, "action", "on", "lights on/off")
	flag.Parse()

	bridge := cinefade.GetBridge(false)
	cinefade.MapRoutes(bridge)

	// make a http server using the goweb.DefaultHttpHandler()
	s := &http.Server{
		Addr:           Address,
		Handler:        goweb.DefaultHttpHandler(),
		ReadTimeout:    10 * time.Second,
		WriteTimeout:   10 * time.Second,
		MaxHeaderBytes: 1 << 20,
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	listener, listenErr := net.Listen("tcp", Address)
	syslog.Info("Server cinefade started")
	syslog.Infof("visit: %s", Address)

	if listenErr != nil {
		syslog.Critf("Could not listen: %s", listenErr)
		os.Exit(1)
	}

	go func() {
		for _ = range c {
			// sig is a ^C, handle it
			// stop the HTTP server
			syslog.Info("Stopping the cinefade server...")
			listener.Close()

			syslog.Info("Tearing down...")
			os.Exit(0)
		}
	}()

	syslog.Critf("Error in Serve: %s", s.Serve(listener))
	os.Exit(1)
}
Exemplo n.º 3
0
func poll(client *http.Client, c chan string) {
	syslog.Info("Launch plex poller")
	conf := config.NewConfig(EtcDir + "/cinefade.conf")
	err := conf.Read()
	if err != nil {
		syslog.Critf("cannot read config: %v", err)
	}
	plexUrl := conf.Get("", "plexUrl")

	for {
		select {
		case <-r:
			syslog.Info("Exit from plex poller")
			r <- true
			return
		case <-time.After(5000 * time.Millisecond):
			req, _ := http.NewRequest("GET", plexUrl, nil)
			resp, err := client.Do(req)
			if err != nil {
				syslog.Warningf("can't access plex %v", err)
				c <- "unknown"
			} else {
				defer resp.Body.Close()

				body, err := ioutil.ReadAll(resp.Body)
				var m MediaContainer
				xml.Unmarshal(body, &m)
				if err != nil {
					syslog.Critf("error: %v", err)
				}
				switch m.Video.Player.State {
				case "":
					c <- "stopped"
				case "paused":
					c <- "paused"
				case "playing":
					c <- "playing"
				default:
					c <- "unknown"
				}
			}
		}
	}
}
Exemplo n.º 4
0
func GetBridge(debug bool) *hue.Bridge {
	conf := config.NewConfig(EtcDir + "/cinefade.conf")
	err := conf.Read()
	if err != nil {
		syslog.Critf("cannot read config: %v", err)
		os.Exit(1)
	}

	hueIpAddr := conf.Get("", "hueIpAddr")
	hueUser := conf.Get("", "hueUser")

	if hueIpAddr == "" || hueUser == "" {
		syslog.Crit("One of configuration hueIpAddr|hueUser not found")
	}

	bridge := hue.NewBridge(hueIpAddr, hueUser)
	if debug {
		bridge.Debug()
	}
	return bridge
}
Exemplo n.º 5
0
func (entity *Entity) Save(iaddress string, pool *redis.Pool) (*Entity, error) {
	resource := strings.TrimSpace(iaddress)
	if len(resource) == 0 {
		entity.Err = ERROR_NO_URL
		entity.Message = "url must be provided in request."
		err := errors.New(entity.Message)
		return entity, err
	}

	u, _ := url.Parse(resource)
	domains := Get("lilliput.alloweddomain", nil).([]interface{})
	flag := true
	for _, d := range domains {
		if d.(string) == u.Host {
			flag = false
		}
	}

	if flag {
		entity.Err = ERROR_INVALID_DOMAIN
		entity.Message = "Invalid domain in url"
		err := errors.New(entity.Message)
		return entity, err
	}

	expression := regexp.MustCompile(EMAIL_REGEX)
	if expression.MatchString(resource) == false {
		entity.Err = ERROR_INVALID_URL
		entity.Message = "Invalid url"
		err := errors.New(entity.Message)
		return entity, err
	}
	entity.Url = iaddress
	bytes := make([]byte, 7)
	db := pool.Get()
	defer db.Close()

	for i := 0; i < 5; i++ {
		rand.Read(bytes)
		for i, b := range bytes {
			bytes[i] = ALPHANUM[b%byte(len(ALPHANUM))]
		}
		id := string(bytes)
		if exists, _ := redis.Bool(db.Do("EXISTS", id)); !exists {
			entity.Token = id
			break
		}
	}

	if entity.Token == "" {
		syslog.Critf("Error: failed to generate token")
		entity.Err = ERROR_TOKEN_GENERATION_FAILED
		entity.Message = "Faild to generate token please try again."
		err := errors.New(entity.Message)
		return entity, err
	}

	reply, err := db.Do("SET", entity.Token, entity.Url)
	if err == nil && reply != "OK" {
		syslog.Critf("Error: %s", err)
		entity.Err = ERROR_FAILED_TO_SAVE
		entity.Message = "Invalid Redis response"
		err := errors.New(entity.Message)
		return entity, err
	}

	entity.Err = SUCCESS
	entity.Tiny = Get("lilliput.domain", "").(string) + entity.Token
	syslog.Critf("Tiny url from %s to %s", entity.Url, entity.Tiny)
	return entity, nil
}