Ejemplo n.º 1
0
// Dial connects to the Redis server at the given network and address.
func Dial(cx appengine.Context, network, address string) (Conn, error) { // lv3 AppEngine
	c, err := socket.Dial(cx, network, address)
	if err != nil {
		return nil, err
	}
	return NewConn(c, 0, 0), nil
}
Ejemplo n.º 2
0
// DialTimeout acts like Dial but takes timeouts for establishing the
// connection to the server, writing a command and reading a reply.  lv3 AppEngine
func DialTimeout(cx appengine.Context, network, address string, connectTimeout, readTimeout,
	writeTimeout time.Duration) (Conn, error) {
	var c *socket.Conn
	var err error
	if connectTimeout > 0 {
		c, err = socket.DialTimeout(cx, network, address, connectTimeout)
	} else {
		c, err = socket.Dial(cx, network, address)
	}
	if err != nil {
		return nil, err
	}
	return NewConn(c, readTimeout, writeTimeout), nil
}
Ejemplo n.º 3
0
// Create a new session. Please note that you have to login to retrieve a
// valid session token.
func NewSession(c *Config, context appengine.Context) (*Session, error) {

	s := new(Session)

	// Configuration
	if c.Username == "" {
		return s, errors.New("Config.Username is empty.")
	}
	if c.Password == "" {
		return s, errors.New("Config.Password is empty.")
	}
	if _, err := os.Stat(c.CertFile); os.IsNotExist(err) {
		return s, errors.New("Config.CertFile does not exist.")
	}
	if _, err := os.Stat(c.KeyFile); os.IsNotExist(err) {
		return s, errors.New("Config.KeyFile does not exist.")
	}
	c.Exchange = strings.ToUpper(c.Exchange)
	if _, exists := endpointMap[c.Exchange]; exists == false {
		c.Exchange = "UK"
	}
	if c.Locale == "" {
		c.Locale = "en"
	}
	s.config = c

	// HTTP client
	cert, err := tls.LoadX509KeyPair(s.config.CertFile, s.config.KeyFile)
	if err != nil {
		return s, err
	}
	ssl := &tls.Config{
		Certificates:       []tls.Certificate{cert},
		InsecureSkipVerify: true,
	}
	ssl.Rand = rand.Reader
	s.httpClient = &http.Client{
		Transport: &http.Transport{
			Dial: func(network, addr string) (net.Conn, error) {
				return socket.Dial(context, network, addr)
			},
			TLSClientConfig: ssl,
		},
	}

	return s, nil
}
Ejemplo n.º 4
0
func (i *Instance) httpClient(c appengine.Context) (client *http.Client, err error) {

	// Create TLS settings for expected TLS certificate.
	// We rely on knowing the cert we expect in advance,
	// rather than a usual certificate chain.
	cpool := x509.NewCertPool()
	if !cpool.AppendCertsFromPEM(i.Certificate) {
		return nil, errors.New("Could not add certificate to pool.")
	}
	tlsConfig := &tls.Config{
		RootCAs:    cpool,
		ServerName: "dreamserver",
	}

	// Create a HTTP client which uses the sockets API rather
	// than the urlfetch API, since we need custom TLS config,
	// in order to be secure.
	transport := &http.Transport{
		TLSClientConfig: tlsConfig,
		Dial: func(network, addr string) (net.Conn, error) {
			conn, err := socket.Dial(c, network, addr)
			if err != nil {
				return nil, err
			}

			// If we don't do this step,
			// sockets time out after five seconds.
			// This is not conductive to our longer requests.
			err = conn.SetReadDeadline(time.Now().Add(50 * time.Minute))
			if err != nil {
				return nil, err
			}
			err = conn.SetWriteDeadline(time.Now().Add(50 * time.Minute))
			if err != nil {
				return nil, err
			}

			return conn, nil
		},
	}
	client = &http.Client{
		Transport: transport,
	}

	return
}
Ejemplo n.º 5
0
func doRequestGet(c appengine.Context, s *Session, key, method string, body *strings.Reader) ([]byte, error) {

	endpoint, err := s.getUrl(key, method)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", endpoint, body)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Accept", "application/json")

	if key == "certLogin" || method == "login" {
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
		// In non-interactive login, X-Application is not validated
		req.Header.Set("X-Application", s.config.ApplicationKey)
	} else {
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("X-Authentication", s.token)
		if key == "account" && method == "getDeveloperAppKeys" {
			req.Header.Del("X-Application")
		} else {
			if s.Live {
				req.Header.Set("X-Application", s.appKeys[LIVE_DATA])
			} else {
				req.Header.Set("X-Application", s.appKeys[DELAY_DATA])
			}
		}
	}

	cert, err := tls.LoadX509KeyPair(s.config.CertFile, s.config.KeyFile)
	if err != nil {
		return nil, err
	}
	ssl := &tls.Config{
		Certificates:       []tls.Certificate{cert},
		InsecureSkipVerify: true,
	}
	ssl.Rand = rand.Reader
	s.httpClient = &http.Client{
		Transport: &http.Transport{
			Dial: func(network, addr string) (net.Conn, error) {
				return socket.Dial(c, network, addr)
			},
			TLSClientConfig: ssl,
		},
	}

	res, err := s.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	if res.StatusCode != 200 {
		return nil, errors.New(res.Status)
	}
	defer res.Body.Close()
	data, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}

	return data, nil
}