Example #1
0
func init() {
	cronOnce.Do(func() {
		r, _ := regexp.Compile("[^a-zA-Z0-9_\\.]")
		cronTable = r.ReplaceAllString(strings.ToLower(config.NewConfig().Name), "-") + "-crons"
		comfirmCronTableExists()
	})
}
Example #2
0
func init() {
	dynamoOnce.Do(func() {
		dynamoCfg = config()
		if host := appcfg.NewConfig().DynamoDbLocal; host != "" {
			dynamoCfg.Endpoint = awssdk.String("http://" + host + ":8000")
		}
	})
}
func TestSessionTable(t *testing.T) {
	actual := sessionTable
	r, _ := regexp.Compile("[^a-zA-Z0-9_\\.]")
	expected := r.ReplaceAllString(strings.ToLower(config.NewConfig().Name), "-") + "-sessions"
	if actual != expected {
		t.Errorf("CronTableName was not fixed in init func. Expected %v, but got %v", expected, actual)
		return
	}
}
Example #4
0
func init() {
	sessionOnce.Do(func() {
		r, _ := regexp.Compile("[^a-zA-Z0-9_\\.]")
		sessionTable = r.ReplaceAllString(strings.ToLower(config.NewConfig().Name), "-") + "-sessions-2015"
		if found, _ := comfirmSessionTableExists(); !found {
			go func() {
				time.Sleep(10 * time.Second)
				SyncReInventSessions(true)
			}()
		}
	})
}
Example #5
0
func main() {
	rand.Seed(time.Now().UnixNano())

	cfg := config.NewConfig()
	logs.Debug.Print("[config] " + cfg.String())

	http.Handle("/", index())
	http.HandleFunc("/alive", alive)
	http.HandleFunc("/version", version)
	http.Handle("/assets/", assets(cfg))

	logs.Info.Printf("[service] listening on port %v", cfg.Port)
	logs.Fatal.Print(http.ListenAndServe(":"+fmt.Sprint(cfg.Port), nil))
}
func TestIndex(t *testing.T) {
	ts := httptest.NewServer(http.Handler(index()))
	defer ts.Close()

	res, err := http.Get(ts.URL)
	if ok := misc.IsSuccessHTTPRequest(t, res, err); !ok {
		return
	}
	actual, _ := misc.ParseHTTPResponse(res)
	expected := config.NewConfig().Name
	if !strings.Contains(actual, expected) {
		t.Errorf("Invalid response. Expected %v, but got %v", expected, actual)
		return
	}
}
func TestAssets(t *testing.T) {
	cfg := config.NewConfig()
	ts := httptest.NewServer(http.Handler(assets(cfg)))
	defer ts.Close()

	res, err := http.Get(ts.URL + "/assets/css/main.css")
	if ok := misc.IsSuccessHTTPRequest(t, res, err); !ok {
		return
	}
	actual, _ := misc.ParseHTTPResponse(res)
	expected := "monospace"
	if !strings.Contains(actual, expected) {
		t.Errorf("Invalid response. Expected %v, but got %v", expected, actual)
		return
	}
}
Example #8
0
func config() *aws.Config {
	log := aws.LogLevel(aws.LogOff)
	cfg := app.NewConfig()
	if cfg.AwsLog {
		log = aws.LogLevel(aws.LogDebug)
	}
	return &aws.Config{
		Credentials: credentials.NewChainCredentials(
			[]credentials.Provider{
				&credentials.EnvProvider{},
				&ec2rolecreds.EC2RoleProvider{ExpiryWindow: cfg.AwsRoleExpiry * time.Minute},
			}),
		Region:   aws.String(os.Getenv("AWS_REGION")),
		LogLevel: log,
	}
}
Example #9
0
func init() {
	cfg = config.NewConfig()

	// Access limitations
	if cfg.LimitRatePerMin > 0 {
		if cfg.LimitBursts > 0 {
			th = throttled.Interval(
				throttled.PerMin(cfg.LimitRatePerMin),
				cfg.LimitBursts, cfg.LimitVaryBy,
				cfg.LimitKeyCache)
		} else {
			th = throttled.RateLimit(
				throttled.PerMin(cfg.LimitRatePerMin),
				cfg.LimitVaryBy, store.NewMemStore(cfg.LimitKeyCache))
		}
	}
}
Example #10
0
func init() {
	cfg := config.NewConfig()
	stage := cfg.Stage
	if !misc.ZeroOrNil(stage) {
		stage = "/" + stage
	}

	/**
	 * sessions
	 * @param string output [The formatting style for response body (html | json).]
	 * @param string q [Space seperated words to use in filtering the response data (for example, best practice).]
	 * @param int type
	 * @param int track
	 * @param int level
	 * @param int date
	 */
	http.Handle("/reinvent/sessions", util.Chain(func(w http.ResponseWriter, r *http.Request) {
		id, found := util.RequestGetParam(r, "id")
		if found {
			session, err := models.GetSession(id)
			if util.IsInvalid(w, err, "@aws.DynamoRecords") {
				return
			}
			util.RenderJSON(w, session, nil)
			return
		}
		output, found := util.RequestGetParam(r, "output")
		if found && (strings.ToLower(output) == "html") {
			token, _, _ := checkTwitterSession(w, r)
			util.RenderHTML(w, []string{"reinvent/index.tmpl"}, struct{ Token models.OAuthAuthorizedToken }{token}, nil)
			return
		}
		cron, err1 := models.GetCronResult("SyncReInventSessions")
		if util.IsInvalid(w, err1, "@aws.DynamoRecord") {
			return
		}
		// get sessions
		sessions, _, err2 := models.GetSessions()
		if util.IsInvalid(w, err2, "@aws.DynamoRecords") {
			return
		}
		// filter
		if q, found := util.RequestGetParam(r, "q"); found {
			splitted := strings.FieldsFunc(q, func(c rune) bool {
				return !unicode.IsLetter(c) && !unicode.IsNumber(c)
			})
			words := make([]string, len(splitted))
			for i, val := range splitted {
				words[i] = strings.ToUpper(val)
			}
			filtered := models.Sessions{}
			for _, session := range sessions {
				if session.Contains(words) {
					filtered = append(filtered, session)
				}
			}
			sessions = filtered
		}
		util.RenderJSON(w, struct {
			Count    int              `json:"count"`
			Sessions []models.Session `json:"sessions"`
			Sync     time.Time        `json:"sync"`
		}{
			Count:    len(sessions),
			Sessions: sessions,
			Sync:     cron.LastEndDate,
		}, nil)
	}))
	http.Handle("/reinvent-sessions", util.Chain(func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, stage+"/reinvent/sessions", http.StatusFound)
	}))

	http.Handle("/reinvent/sync-sessions", util.Chain(func(w http.ResponseWriter, r *http.Request) {
		sessions, err := models.SyncReInventSessions(true)
		util.RenderJSON(w, sessions, err)
	}))

}
func init() {
	sessions = map[string]*oauth1a.UserConfig{}
	cfg := config.NewConfig()
	twitter = &oauth1a.Service{
		RequestURL:   "https://api.twitter.com/oauth/request_token",
		AuthorizeURL: "https://api.twitter.com/oauth/authorize",
		AccessURL:    "https://api.twitter.com/oauth/access_token",
		ClientConfig: &oauth1a.ClientConfig{
			ConsumerKey:    cfg.TwitterKey,
			ConsumerSecret: cfg.TwitterSecret,
			CallbackURL:    cfg.TwitterCallback,
		},
		Signer: new(oauth1a.HmacSha1Signer),
	}

	/**
	 * Twitter OAuth
	 */
	http.Handle("/twitter/signin", util.Chain(func(w http.ResponseWriter, r *http.Request) {
		http.SetCookie(w, util.SetCookie(twitterSessionKey, "", -1))
		_, sessionID, ok := checkTwitterSession(w, r)
		if !ok {
			logs.Error.Print("Could not generate new sessionID.")
			http.Error(w, "Problem generating new session", http.StatusInternalServerError)
			return
		}
		session := &oauth1a.UserConfig{}
		if err := session.GetRequestToken(twitter, new(http.Client)); err != nil {
			logs.Error.Printf("Could not get request token: %v", err)
			http.Error(w, fmt.Sprintf("Problem getting the request token: %v", err), http.StatusInternalServerError)
			return
		}
		url, err := session.GetAuthorizeURL(twitter)
		if err != nil {
			logs.Error.Printf("Could not get authorization URL: %v", err)
			http.Error(w, "Problem getting the authorization URL", http.StatusInternalServerError)
			return
		}
		sessions[sessionID] = session
		http.Redirect(w, r, url, http.StatusFound)
	}))

	http.Handle("/twitter/callback", util.Chain(func(w http.ResponseWriter, r *http.Request) {
		_, found := util.RequestGetParam(r, "denied")
		if found {
			http.Redirect(w, r, "/reinvent/sessions?output=html", http.StatusFound)
			return
		}
		authorizedToken, sessionID, ok := checkTwitterSession(w, r)
		if !ok {
			logs.Error.Print("Could not generate new sessionID.")
			http.Error(w, "Problem generating new session", http.StatusInternalServerError)
			return
		}
		if authorizedToken.ID != "" {
			http.Redirect(w, r, "/", http.StatusFound)
			return
		}
		session, ok := sessions[sessionID]
		if !ok {
			logs.Error.Print("Could not find user config in sesions storage.")
			http.Error(w, "Invalid session", http.StatusBadRequest)
			return
		}
		token, verifier, err := session.ParseAuthorize(r, twitter)
		if err != nil {
			logs.Error.Printf("Could not parse authorization: %v", err)
			http.Error(w, "Problem parsing authorization", http.StatusInternalServerError)
			return
		}
		if err = session.GetAccessToken(token, verifier, twitter, new(http.Client)); err != nil {
			logs.Error.Printf("Error getting access token: %v", err)
			http.Error(w, "Problem getting an access token", http.StatusInternalServerError)
			return
		}
		delete(sessions, sessionID)

		authorized := models.OAuthAuthorizedToken{
			ID:                session.AccessValues.Get("user_id"),
			ScreenName:        session.AccessValues.Get("screen_name"),
			AccessTokenKey:    session.AccessTokenKey,
			AccessTokenSecret: session.AccessTokenSecret,
			CognitoPoolID:     strings.Replace(cfg.CognitoPoolID, ":", "*", -1),
			CognitoRoleArn:    strings.Replace(cfg.CognitoRoleArn, ":", "*", -1),
		}
		bytes, _ := json.Marshal(authorized)
		http.SetCookie(w, util.SetCookie(twitterSessionKey, string(bytes), 60*60*24))
		http.SetCookie(w, util.SetCookie(twitterTemporaryKey, "", -1))
		http.Redirect(w, r, "/reinvent/sessions?output=html", http.StatusFound)
	}))
}