Example #1
0
func createReadClient(m *medium) (readClient, error) {
	// no output, no client
	if m == nil {
		return nil, nil
	}

	switch m.typ {
	case innkeeper:
		return createInnkeeperClient(m)

	case etcd:
		return etcdclient.New(etcdclient.Options{
			Endpoints: urlsToStrings(m.urls),
			Prefix:    m.path,
			Insecure:  insecure})

	case stdin:
		return &stdinReader{reader: os.Stdin}, nil

	case file:
		return eskipfile.Open(m.path)

	case inline:
		return &inlineReader{routes: m.eskip}, nil

	case inlineIds:
		return &idsReader{ids: m.ids}, nil

	default:
		return nil, invalidInputType
	}
}
Example #2
0
func createDataClients(o Options, auth innkeeper.Authentication) ([]routing.DataClient, error) {
	var clients []routing.DataClient

	if o.RoutesFile != "" {
		f, err := eskipfile.Open(o.RoutesFile)
		if err != nil {
			return nil, err
		}

		clients = append(clients, f)
	}

	if o.InnkeeperUrl != "" {
		ic, err := innkeeper.New(innkeeper.Options{
			o.InnkeeperUrl, o.ProxyOptions.Insecure(), auth,
			o.InnkeeperPreRouteFilters, o.InnkeeperPostRouteFilters})
		if err != nil {
			return nil, err
		}

		clients = append(clients, ic)
	}

	if len(o.EtcdUrls) > 0 {
		clients = append(clients, etcd.New(o.EtcdUrls, o.EtcdPrefix))
	}

	return clients, nil
}
Example #3
0
func Example() {
	// create etcd data client:
	dataClient := etcd.New([]string{"https://etcd.example.org"}, "/skipper")

	// create http.Handler:
	proxy.New(
		routing.New(routing.Options{
			FilterRegistry: builtin.MakeRegistry(),
			DataClients:    []routing.DataClient{dataClient}}),
		proxy.OptionsNone)
}
Example #4
0
// insert/update all routes to a medium (currently only etcd).
func upsertAll(routes routeList, m *medium) error {
	client := etcdclient.New(urlsToStrings(m.urls), m.path)
	for _, r := range routes {
		ensureId(r)
		err := client.Upsert(r)
		if err != nil {
			return err
		}
	}

	return nil
}
func Example() {
	// create etcd data client:
	dataClient, err := etcd.New(etcd.Options{[]string{"https://etcd.example.org"}, "/skipper", 0})
	if err != nil {
		log.Fatal(err)
	}

	// create http.Handler:
	proxy.New(
		routing.New(routing.Options{
			FilterRegistry: builtin.MakeRegistry(),
			DataClients:    []routing.DataClient{dataClient}}),
		proxy.OptionsNone)
}
Example #6
0
func createWriteClient(out *medium) (writeClient, error) {
	// no output, no client
	if out == nil {
		return nil, nil
	}

	switch out.typ {
	case innkeeper:
		return createInnkeeperClient(out)
	case etcd:
		return etcdclient.New(etcdclient.Options{Endpoints: urlsToStrings(out.urls), Prefix: out.path})
	}
	return nil, invalidOutput
}
Example #7
0
// delete all items in 'routes' that fulfil 'cond'.
func deleteAllIf(routes routeList, m *medium, cond routePredicate) error {
	client := etcdclient.New(urlsToStrings(m.urls), m.path)
	for _, r := range routes {
		if !cond(r) {
			continue
		}

		err := client.Delete(r.Id)
		if err != nil {
			return err
		}
	}

	return nil
}
Example #8
0
func createDataClients(o Options, auth innkeeper.Authentication) ([]routing.DataClient, error) {
	var clients []routing.DataClient

	if o.RoutesFile != "" {
		f, err := eskipfile.Open(o.RoutesFile)
		if err != nil {
			log.Error(err)
			return nil, err
		}

		clients = append(clients, f)
	}

	if o.InnkeeperUrl != "" {
		ic, err := innkeeper.New(innkeeper.Options{
			o.InnkeeperUrl, o.InnkeeperInsecure, auth,
			o.InnkeeperPreRouteFilters, o.InnkeeperPostRouteFilters})
		if err != nil {
			log.Error(err)
			return nil, err
		}

		clients = append(clients, ic)
	}

	if len(o.EtcdUrls) > 0 {
		etcdClient, err := etcd.New(etcd.Options{
			o.EtcdUrls,
			o.EtcdPrefix,
			o.EtcdWaitTimeout,
			o.EtcdInsecure})
		if err != nil {
			return nil, err
		}

		clients = append(clients, etcdClient)
	}

	if o.KubernetesURL != "" {
		clients = append(clients, kubernetes.New(kubernetes.Options{
			KubernetesURL:      o.KubernetesURL,
			ProvideHealthcheck: o.KubernetesHealthcheck,
		}))
	}

	return clients, nil
}
Example #9
0
func Example() {
	// create etcd data client:
	dataClient, err := etcd.New(etcd.Options{[]string{"https://etcd.example.org"}, "/skipper", 0, false})
	if err != nil {
		log.Fatal(err)
	}

	// create routing object:
	rt := routing.New(routing.Options{
		FilterRegistry: builtin.MakeRegistry(),
		DataClients:    []routing.DataClient{dataClient}})
	defer rt.Close()

	// create http.Handler:
	p := proxy.New(rt, proxy.OptionsNone)
	defer p.Close()
}
Example #10
0
// load and parse routes from etcd.
func loadEtcd(urls []*url.URL, prefix string) (loadResult, error) {
	client := etcdclient.New(urlsToStrings(urls), prefix)
	info, err := client.LoadAndParseAll()
	return mapRouteInfo(info), err
}