func TestMain(m *testing.M) {
var err error
apiUrl := "http://localhost:8080/v1/projects/1a5/schema"
accessKey := ""
secretKey := ""
//1a5 is admin account, 1a6 will be the service account, therefore trying to create a new account of type starting from 1a7
//if 1a7 exists, and is not a user account then a new account with the next available id will be created
id := createIfNoAccount("1a7")
apiUrl2 := "http://localhost:8080/v1/projects/" + id + "/schema"
apiClient, err = client.NewRancherClient(&client.ClientOpts{
Url: apiUrl,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
log.Fatal("Error while initializing rancher client, err = ", err)
}
apiClient2, err = client.NewRancherClient(&client.ClientOpts{
Url: apiUrl2,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
log.Fatal("Error while initializing rancher client, err = ", err)
}
os.Exit(m.Run())
}
func TestMain(m *testing.M) {
var err error
adminUrl := "http://localhost:8080/v1"
apiUrl := adminUrl + "/projects/1a5/schemas"
accessKey := ""
secretKey := ""
adminClient, err := client.NewRancherClient(&client.ClientOpts{
Url: adminUrl,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
log.Fatal(err)
}
for i := 0; ; i++ {
handlers, err := adminClient.ExternalHandler.List(&client.ListOpts{
Filters: map[string]interface{}{
"name": "rancher-compose-executor",
"state": "active",
},
})
if err != nil {
log.Fatal(err)
}
if len(handlers.Data) > 0 {
break
}
if i > 3 {
log.Fatal("Handler is not available")
}
time.Sleep(1 * time.Second)
}
id := createIfNoAccount(adminUrl, "rancher-compose-executor-tests")
apiUrl2 := adminUrl + "/projects/" + id + "/schemas"
apiClient, err = client.NewRancherClient(&client.ClientOpts{
Url: apiUrl,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
log.Fatal("Error while initializing rancher client, err = ", err)
}
apiClient2, err = client.NewRancherClient(&client.ClientOpts{
Url: apiUrl2,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
log.Fatal("Error while initializing rancher client, err = ", err)
}
os.Exit(m.Run())
}
func (c *Context) open() error {
if c.isOpen {
return nil
}
if err := c.readRancherConfig(); err != nil {
return err
}
if c.Url == "" {
return fmt.Errorf("RANCHER_URL is not set")
}
if client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: c.Url,
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
}); err != nil {
return err
} else {
c.Client = client
}
if err := c.loadEnv(); err != nil {
return err
}
c.isOpen = true
return nil
}
func createIfNoAccount(apiUrl, name string) string {
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: apiUrl,
})
if err != nil {
log.Fatalf("Error while initializing rancher client, err = [%v]", err)
}
accs, err := apiClient.Account.List(&client.ListOpts{
Filters: map[string]interface{}{
"name": name,
},
})
if err != nil {
log.Fatalf("Failed to list accounts")
}
if len(accs.Data) == 0 {
acc, err := apiClient.Account.Create(&client.Account{
Kind: "project",
Name: name,
})
if err != nil {
log.Fatalf("Error while creating new account, err = [%v]", err)
}
waitTransition(apiClient, acc)
return acc.Id
}
return accs.Data[0].Id
}
func NewEventRouter(name string, priority int, apiUrl string, accessKey string, secretKey string,
apiClient *client.RancherClient, eventHandlers map[string]EventHandler, resourceName string, workerCount int) (*EventRouter, error) {
if apiClient == nil {
var err error
apiClient, err = client.NewRancherClient(&client.ClientOpts{
Url: apiUrl,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
return nil, err
}
}
// TODO Get subscribe collection URL from API instead of hard coding
subscribeUrl := strings.Replace(apiUrl+"/subscribe", "http", "ws", -1)
return &EventRouter{
name: name,
priority: priority,
apiUrl: apiUrl,
accessKey: accessKey,
secretKey: secretKey,
apiClient: apiClient,
subscribeUrl: subscribeUrl,
eventHandlers: eventHandlers,
workerCount: workerCount,
mu: &sync.Mutex{},
resourceName: resourceName,
}, nil
}
func NewEventRouter(name string, priority int, apiURL string, accessKey string, secretKey string,
apiClient *client.RancherClient, eventHandlers map[string]EventHandler, resourceName string, workerCount int,
pingConfig PingConfig) (*EventRouter, error) {
if apiClient == nil {
var err error
apiClient, err = client.NewRancherClient(&client.ClientOpts{
Timeout: time.Second * 30,
Url: apiURL,
AccessKey: accessKey,
SecretKey: secretKey,
})
if err != nil {
return nil, err
}
}
// TODO Get subscribe collection URL from API instead of hard coding
subscribeURL := strings.Replace(apiURL+"/subscribe", "http", "ws", -1)
return &EventRouter{
name: name,
priority: priority,
apiURL: apiURL,
accessKey: accessKey,
secretKey: secretKey,
apiClient: apiClient,
subscribeURL: subscribeURL,
eventHandlers: eventHandlers,
workerCount: workerCount,
resourceName: resourceName,
pingConfig: pingConfig,
}, nil
}
// NewClient returns a new client for the Rancher/Cattle API
func NewClient(rancherUrl string, rancherAccessKey string, rancherSecretKey string) (*Client, error) {
opts := &rancherClient.ClientOpts{
Url: rancherUrl,
AccessKey: rancherAccessKey,
SecretKey: rancherSecretKey,
Timeout: time.Second * 5,
}
var err error
var apiClient *rancherClient.RancherClient
maxTime := 10 * time.Second
for i := 1 * time.Second; i < maxTime; i *= time.Duration(2) {
apiClient, err = rancherClient.NewRancherClient(opts)
if err == nil {
break
}
time.Sleep(i)
}
if err != nil {
return nil, err
}
return &Client{apiClient}, nil
}
func GetRancherClient(conf Config) (*client.RancherClient, error) {
return client.NewRancherClient(&client.ClientOpts{
Url: conf.CattleURL,
AccessKey: conf.CattleAccessKey,
SecretKey: conf.CattleSecretKey,
})
}
func NewCattleClient(cattleUrl string, cattleAccessKey string, cattleSecretKey string) (*CattleClient, error) {
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: cattleUrl,
AccessKey: cattleAccessKey,
SecretKey: cattleSecretKey,
})
if err != nil {
return nil, err
}
return &CattleClient{
rancherClient: apiClient,
}, nil
}
func createEnv(rancherUrl, projectName string, composeBytes []byte, rancherComposeMap map[string]rancher.RancherConfig, env *client.Environment) error {
context := rancher.Context{
Url: rancherUrl,
RancherConfig: rancherComposeMap,
Uploader: nil,
}
context.ProjectName = projectName
context.ComposeBytes = composeBytes
context.ConfigLookup = nil
context.EnvironmentLookup = &lookup.OsEnvLookup{}
context.LoggerFactory = logger.NewColorLoggerFactory()
context.ServiceFactory = &rancher.RancherServiceFactory{
Context: &context,
}
p := project.NewProject(&context.Context)
err := p.Parse()
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Errorf("Error parsing docker-compose.yml")
return err
}
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: rancherUrl,
AccessKey: os.Getenv("CATTLE_ACCESS_KEY"),
SecretKey: os.Getenv("CATTLE_SECRET_KEY"),
})
context.Client = apiClient
c := &context
c.Environment = env
context.SidekickInfo = rancher.NewSidekickInfo(p)
err = p.Create([]string{}...)
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Error("Error while creating project.")
return err
}
return nil
}
func (c *Config) EnvironmentClient(env string) (*rancherClient.RancherClient, error) {
url := c.APIURL + "/projects/" + env + "/schemas"
client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: url,
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
})
if err != nil {
return nil, err
}
log.Printf("[INFO] Rancher Client configured for url: %s", url)
return client, nil
}
// Create creates a generic Rancher client
func (c *Config) CreateClient() error {
client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: c.APIURL,
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
})
if err != nil {
return err
}
log.Printf("[INFO] Rancher Client configured for url: %s", c.APIURL)
c.RancherClient = client
return nil
}
func NewCattleClient(cattleUrl, cattleAccessKey, cattleSecretKey string) (*CattleClient, error) {
if cattleUrl == "" {
return nil, errors.New("cattle url is empty")
}
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: cattleUrl,
AccessKey: cattleAccessKey,
SecretKey: cattleSecretKey,
})
if err != nil {
return nil, err
}
return &CattleClient{
rancherClient: apiClient,
}, nil
}
func (c *Context) loadClient() (*rancherClient.RancherClient, error) {
if c.Client == nil {
if c.Url == "" {
return nil, fmt.Errorf("RANCHER_URL is not set")
}
if client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: c.Url,
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
}); err != nil {
return nil, err
} else {
c.Client = client
}
}
return c.Client, nil
}
func (c *Context) loadRancherClient() error {
if c.Client == nil {
if c.RancherURL == "" {
return fmt.Errorf("RancherURL is nil, can not change Scale")
}
client, err := client.NewRancherClient(&client.ClientOpts{
Url: c.RancherURL,
AccessKey: c.accessKey,
SecretKey: c.secretKey,
})
if err != nil {
return err
}
c.Client = client
}
return nil
}
func run() error {
if os.Getenv("PROXY_DEBUG") != "" {
logrus.SetLevel(logrus.DebugLevel)
}
client, err := rancher.NewRancherClient(&rancher.ClientOpts{
Url: os.Getenv("CATTLE_URL"),
AccessKey: os.Getenv("CATTLE_ACCESS_KEY"),
SecretKey: os.Getenv("CATTLE_SECRET_KEY"),
})
if err != nil {
return err
}
tlsConfig, err := loadTLSConfig("ca.pem", "server-cert.pem", "server-key.pem")
if err != nil {
logrus.Infof("Not using TLS: %v", err)
}
wg := sync.WaitGroup{}
for i := range os.Args {
if len(os.Args) <= i+1 || i%2 == 0 {
continue
}
wg.Add(1)
go func(i int) {
defer wg.Done()
host := os.Args[i]
listen := os.Args[i+1]
logrus.Infof("Proxying %s on %s", host, listen)
proxy := dockerapiproxy.NewProxy(client, host, listen)
proxy.TlsConfig = tlsConfig
if err := proxy.ListenAndServe(); err != nil {
logrus.Errorf("Error on %s [%s]: %v", host, listen, err)
}
}(i)
}
wg.Wait()
return nil
}
func createIfNoAccount(id string) string {
apiUrl := "http://localhost:8080/v1"
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: apiUrl,
})
if err != nil {
log.Fatalf("Error while initializing rancher client, err = [%v]", err)
}
acc, err := apiClient.Account.ById(id)
if err != nil || (err == nil && acc != nil && acc.Kind != "project") {
acc, err = apiClient.Account.Create(&client.Account{
Kind: "project",
Name: "user",
})
if err != nil {
log.Fatalf("Error while creating new account, err = [%v]", err)
}
waitTransition(apiClient, acc)
}
return acc.Id
}
func (c *Context) open() error {
if c.isOpen {
return nil
}
c.fixUpProjectName()
if err := c.readRancherConfig(); err != nil {
return err
}
if c.Url == "" {
return fmt.Errorf("RANCHER_URL is not set")
}
if client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: c.Url,
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
}); err != nil {
return err
} else {
c.Client = client
}
if envSchema, ok := c.Client.Types["environment"]; !ok || !Contains(envSchema.CollectionMethods, "POST") {
return fmt.Errorf("Can not create a stack, check API key [%s] for [%s]", c.AccessKey, c.Url)
}
c.checkVersion()
if err := c.loadEnv(); err != nil {
return err
}
c.isOpen = true
return nil
}
func (s *Server) getClient(r *http.Request) (*client.RancherClient, error) {
return client.NewRancherClient(&client.ClientOpts{
Url: "http://localhost:8080/v1/projects/1a5/schemas",
})
}
func main() {
vargs := Rancher{StartFirst: true}
plugin.Param("vargs", &vargs)
err := plugin.Parse()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
if len(vargs.Url) == 0 || len(vargs.AccessKey) == 0 || len(vargs.SecretKey) == 0 || len(vargs.Service) == 0 {
return
}
if !strings.HasPrefix(vargs.Image, "docker:") {
vargs.Image = fmt.Sprintf("docker:%s", vargs.Image)
}
var wantedService, wantedStack string
if strings.Contains(vargs.Service, "/") {
parts := strings.SplitN(vargs.Service, "/", 2)
wantedStack = parts[0]
wantedService = parts[1]
} else {
wantedService = vargs.Service
}
rancher, err := client.NewRancherClient(&client.ClientOpts{
Url: vargs.Url,
AccessKey: vargs.AccessKey,
SecretKey: vargs.SecretKey,
})
if err != nil {
fmt.Printf("Failed to create rancher client: %s\n", err)
os.Exit(1)
}
var stackId string
if wantedStack != "" {
environments, err := rancher.Environment.List(&client.ListOpts{})
if err != nil {
fmt.Printf("Failed to list rancher environments: %s\n", err)
os.Exit(1)
}
for _, env := range environments.Data {
if env.Name == wantedStack {
stackId = env.Id
}
}
if stackId == "" {
fmt.Printf("Unable to find stack %s\n", wantedStack)
os.Exit(1)
}
}
services, err := rancher.Service.List(&client.ListOpts{})
if err != nil {
fmt.Printf("Failed to list rancher services: %s\n", err)
os.Exit(1)
}
found := false
var service client.Service
for _, svc := range services.Data {
if svc.Name == wantedService && ((wantedStack != "" && svc.EnvironmentId == stackId) || wantedStack == "") {
service = svc
found = true
}
}
if !found {
fmt.Printf("Unable to find service %s\n", vargs.Service)
os.Exit(1)
}
service.LaunchConfig.ImageUuid = vargs.Image
upgrade := &client.ServiceUpgrade{}
upgrade.InServiceStrategy = &client.InServiceUpgradeStrategy{
LaunchConfig: service.LaunchConfig,
SecondaryLaunchConfigs: service.SecondaryLaunchConfigs,
StartFirst: vargs.StartFirst,
}
upgrade.ToServiceStrategy = &client.ToServiceUpgradeStrategy{}
_, err = rancher.Service.ActionUpgrade(&service, upgrade)
if err != nil {
fmt.Printf("Unable to upgrade service %s\n", vargs.Service)
os.Exit(1)
}
fmt.Printf("Upgraded %s to %s\n", vargs.Service, vargs.Image)
}
func updateEcr(vargs Rancher) error {
fmt.Printf("Updating ECR Credentials\n")
ecrClient := ecr.New(session.New())
resp, err := ecrClient.GetAuthorizationToken(&ecr.GetAuthorizationTokenInput{})
if err != nil {
return err
}
if len(resp.AuthorizationData) < 1 {
return errors.New("Request did not return authorization data")
}
bytes, err := base64.StdEncoding.DecodeString(*resp.AuthorizationData[0].AuthorizationToken)
if err != nil {
fmt.Printf("Error decoding authorization token: %s\n", err)
return err
}
token := string(bytes[:len(bytes)])
authTokens := strings.Split(token, ":")
if len(authTokens) != 2 {
return fmt.Errorf("Authorization token does not contain data in <user>:<password> format: %s", token)
}
registryURL, err := url.Parse(*resp.AuthorizationData[0].ProxyEndpoint)
if err != nil {
fmt.Printf("Error parsing registry URL: %s\n", err)
return err
}
ecrUsername := authTokens[0]
ecrPassword := authTokens[1]
ecrURL := registryURL.Host
rancher, err := client.NewRancherClient(&client.ClientOpts{
Url: vargs.URL,
AccessKey: vargs.AccessKey,
SecretKey: vargs.SecretKey,
})
if err != nil {
fmt.Printf("Failed to create rancher client: %s\n", err)
return err
}
registries, err := rancher.Registry.List(&client.ListOpts{})
if err != nil {
fmt.Printf("Failed to retrieve registries: %s\n", err)
return err
}
for _, registry := range registries.Data {
serverAddress, err := url.Parse(registry.ServerAddress)
if err != nil {
fmt.Printf("Failed to parse configured registry URL %s\n", registry.ServerAddress)
break
}
registryHost := serverAddress.Host
if registryHost == "" {
registryHost = serverAddress.Path
}
if registryHost == ecrURL {
credentials, err := rancher.RegistryCredential.List(&client.ListOpts{
Filters: map[string]interface{}{
"registryId": registry.Id,
},
})
if err != nil {
fmt.Printf("Failed to retrieved registry credentials for id: %s, %s\n", registry.Id, err)
break
}
if len(credentials.Data) != 1 {
fmt.Printf("No credentials retrieved for registry: %s\n", registry.Id)
break
}
credential := credentials.Data[0]
_, err = rancher.RegistryCredential.Update(&credential, &client.RegistryCredential{
PublicValue: ecrUsername,
SecretValue: ecrPassword,
})
if err != nil {
fmt.Printf("Failed to update registry credential %s, %s\n", credential.Id, err)
} else {
fmt.Printf("Successfully updated credentials %s for registry %s; registry address: %s\n", credential.Id, registry.Id, registryHost)
}
break
}
fmt.Printf("Failed to find configured registry to update for URL %s\n", ecrURL)
}
return nil
}
func Init(root string, config map[string]string) (convoydriver.ConvoyDriver, error) {
dev := &Device{
Root: root,
}
exists, err := util.ObjectExists(dev)
if err != nil {
return nil, err
}
if exists {
if err := util.ObjectLoad(dev); err != nil {
return nil, err
}
dev.RancherURL = override(dev.RancherURL, config[LH_RANCHER_URL])
dev.RancherAccessKey = override(dev.RancherAccessKey, config[LH_RANCHER_ACCESS_KEY])
dev.RancherSecretKey = override(dev.RancherSecretKey, config[LH_RANCHER_SECRET_KEY])
} else {
if err := util.MkdirIfNotExists(root); err != nil {
return nil, err
}
url := config[LH_RANCHER_URL]
accessKey := config[LH_RANCHER_ACCESS_KEY]
secretKey := config[LH_RANCHER_SECRET_KEY]
if url == "" || accessKey == "" || secretKey == "" {
return nil, fmt.Errorf("Missing required parameter. lh.rancherurl or lh.rancheraccesskey or lh.ranchersecretkey")
}
if _, exists := config[LH_DEFAULT_VOLUME_SIZE]; !exists {
config[LH_DEFAULT_VOLUME_SIZE] = DEFAULT_VOLUME_SIZE
}
volumeSize, err := util.ParseSize(config[LH_DEFAULT_VOLUME_SIZE])
if err != nil || volumeSize == 0 {
return nil, fmt.Errorf("Illegal default volume size specified")
}
dev = &Device{
Root: root,
RancherURL: url,
RancherAccessKey: accessKey,
RancherSecretKey: secretKey,
DefaultVolumeSize: volumeSize,
}
}
containerName := config[LH_CONTAINER_NAME]
if containerName == "" {
handler := metadata.NewClient(RANCHER_METADATA_URL)
container, err := handler.GetSelfContainer()
if err != nil {
return nil, err
}
containerName = container.UUID
}
log.Debugf("Try to connect to Rancher server at %s [%s:%s]", dev.RancherURL, dev.RancherAccessKey, dev.RancherSecretKey)
client, err := rancherClient.NewRancherClient(&rancherClient.ClientOpts{
Url: dev.RancherURL,
AccessKey: dev.RancherAccessKey,
SecretKey: dev.RancherSecretKey,
})
if err != nil {
return nil, fmt.Errorf("Failed to establish connection to Rancher server")
}
if err := util.ObjectSave(dev); err != nil {
return nil, err
}
d := &Driver{
client: client,
containerName: containerName,
Device: *dev,
}
return d, nil
}