Skip to content

Commit 29e6c60

Browse files
FabianKrammFabianKramm
committed
Resolve #208, #207, #206, #203 
1 parent 5af8a34 commit 29e6c60

5 files changed

Lines changed: 118 additions & 83 deletions

File tree

‎cmd/up.go‎

Lines changed: 30 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -200,20 +200,23 @@ func (cmd *UpCmd) initRegistries() {
200200

201201
if config.Services.InternalRegistry != nil {
202202
registryConf, regConfExists := registryMap["internal"]
203-
204203
if !regConfExists {
205204
log.Fatal("Registry config not found for internal registry")
206205
}
206+
207207
log.StartWait("Initializing internal registry")
208208
err := registry.InitInternalRegistry(cmd.kubectl, cmd.helm, config.Services.InternalRegistry, registryConf)
209-
210-
err = configutil.SaveConfig()
211209
log.StopWait()
212210

213211
if err != nil {
214212
log.Fatalf("Internal registry error: %v", err)
215213
}
216214

215+
err = configutil.SaveConfig()
216+
if err != nil {
217+
log.Fatalf("Saving config error: %v", err)
218+
}
219+
217220
log.Done("Internal registry started")
218221
}
219222

@@ -222,12 +225,17 @@ func (cmd *UpCmd) initRegistries() {
222225
username := ""
223226
password := *registryConf.Auth.Password
224227
email := "noreply@devspace-cloud.com"
228+
registryURL := ""
225229

226230
if registryConf.Auth.Username != nil {
227231
username = *registryConf.Auth.Username
228232
}
233+
if registryConf.URL != nil {
234+
registryURL = *registryConf.URL
235+
}
236+
229237
log.StartWait("Creating image pull secret for registry: " + registryName)
230-
err := registry.CreatePullSecret(cmd.kubectl, *config.DevSpace.Release.Namespace, *registryConf.URL, username, password, email)
238+
err := registry.CreatePullSecret(cmd.kubectl, *config.DevSpace.Release.Namespace, registryURL, username, password, email)
231239
log.StopWait()
232240

233241
if err != nil {
@@ -238,13 +246,14 @@ func (cmd *UpCmd) initRegistries() {
238246
}
239247

240248
func (cmd *UpCmd) shouldRebuild(imageConf *v1.ImageConfig, dockerfilePath string, buildFlagChanged bool) bool {
241-
mustRebuild := true
242-
dockerfileInfo, statErr := os.Stat(dockerfilePath)
243249
var dockerfileModTime time.Time
244250

245-
if statErr != nil {
251+
mustRebuild := true
252+
dockerfileInfo, err := os.Stat(dockerfilePath)
253+
254+
if err != nil {
246255
if imageConf.Build.LatestTimestamp == nil {
247-
log.Fatalf("Dockerfile missing: %s", statErr.Error())
256+
log.Fatalf("Dockerfile missing: %v", err)
248257
} else {
249258
mustRebuild = false
250259
}
@@ -301,13 +310,15 @@ func (cmd *UpCmd) buildImages(buildFlagChanged bool) bool {
301310
var imageBuilder builder.Interface
302311

303312
buildInfo := "Building image '%s' with engine '%s'"
313+
engineName := ""
314+
registryURL := ""
304315

305-
registryURL := *registryConf.URL
306-
316+
if registryConf.URL != nil {
317+
registryURL = *registryConf.URL
318+
}
307319
if registryURL == "hub.docker.com" {
308320
registryURL = ""
309321
}
310-
engineName := ""
311322

312323
if imageConf.Build.Engine.Kaniko != nil {
313324
engineName = "kaniko"
@@ -336,7 +347,11 @@ func (cmd *UpCmd) buildImages(buildFlagChanged bool) bool {
336347
if buildErr == nil {
337348
username := ""
338349
password := ""
350+
registryURL := ""
339351

352+
if registryConf.URL != nil {
353+
registryURL = *registryConf.URL
354+
}
340355
if registryConf.Auth != nil {
341356
if registryConf.Auth.Username != nil {
342357
username = *registryConf.Auth.Username
@@ -346,12 +361,12 @@ func (cmd *UpCmd) buildImages(buildFlagChanged bool) bool {
346361
password = *registryConf.Auth.Password
347362
}
348363
}
349-
log.StartWait("Authenticating (" + *registryConf.URL + ")")
364+
log.StartWait("Authenticating (" + registryURL + ")")
350365
_, buildErr = imageBuilder.Authenticate(username, password, len(username) == 0)
351366
log.StopWait()
352367

353368
if buildErr == nil {
354-
log.Done("Authentication successful (" + *registryConf.URL + ")")
369+
log.Done("Authentication successful (" + registryURL + ")")
355370
buildOptions := &types.ImageBuildOptions{}
356371

357372
if imageConf.Build.Options != nil {
@@ -365,7 +380,7 @@ func (cmd *UpCmd) buildImages(buildFlagChanged bool) bool {
365380
buildErr = imageBuilder.PushImage()
366381

367382
if buildErr == nil {
368-
log.Info("Image pushed to registry (" + *registryConf.URL + ")")
383+
log.Info("Image pushed to registry (" + registryURL + ")")
369384
}
370385
}
371386
}
@@ -395,7 +410,6 @@ func (cmd *UpCmd) initHelm() {
395410
defer log.StopWait()
396411

397412
client, err := helmClient.NewClient(cmd.kubectl, false)
398-
399413
if err != nil {
400414
log.Fatalf("Error initializing helm client: %s", err.Error())
401415
}
@@ -525,7 +539,7 @@ func (cmd *UpCmd) startSync() []*synctool.SyncConfig {
525539
syncConfigs := make([]*synctool.SyncConfig, 0, len(*config.DevSpace.Sync))
526540

527541
for _, syncPath := range *config.DevSpace.Sync {
528-
absLocalPath, err := filepath.Abs(cmd.workdir + *syncPath.LocalSubPath)
542+
absLocalPath, err := filepath.Abs(*syncPath.LocalSubPath)
529543

530544
if err != nil {
531545
log.Panicf("Unable to resolve localSubPath %s: %s", *syncPath.LocalSubPath, err.Error())

‎pkg/devspace/clients/helm/client.go‎

Lines changed: 47 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -82,15 +82,13 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
8282

8383
tillerConfig := config.Services.Tiller
8484
kubeconfig, err := kubectl.GetClientConfig()
85-
8685
if err != nil {
8786
return nil, err
8887
}
8988

90-
tillerErr := ensureTiller(kubectlClient, config, upgradeTiller)
91-
92-
if tillerErr != nil {
93-
return nil, tillerErr
89+
err = ensureTiller(kubectlClient, config, upgradeTiller)
90+
if err != nil {
91+
return nil, err
9492
}
9593

9694
var tunnel *kube.Tunnel
@@ -104,7 +102,6 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
104102
// Next we wait till we can establish a tunnel to the running pod
105103
for tunnelWaitTime > 0 {
106104
tunnel, err = portforwarder.New(*tillerConfig.Release.Namespace, kubectlClient, kubeconfig)
107-
108105
if err == nil {
109106
break
110107
}
@@ -146,7 +143,6 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
146143
}
147144

148145
homeDir, err := homedir.Dir()
149-
150146
if err != nil {
151147
return nil, err
152148
}
@@ -163,7 +159,10 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
163159
_, repoFileNotFound := os.Stat(repoFile)
164160

165161
if repoFileNotFound != nil {
166-
fsutil.WriteToFile([]byte(defaultRepositories), repoFile)
162+
err = fsutil.WriteToFile([]byte(defaultRepositories), repoFile)
163+
if err != nil {
164+
return nil, err
165+
}
167166
}
168167

169168
wrapper := &HelmClientWrapper{
@@ -174,10 +173,13 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
174173
TillerConfig: tillerConfig,
175174
kubectl: kubectlClient,
176175
}
177-
_, stableRepoCacheNotFoundErr := os.Stat(stableRepoCachePathAbs)
178176

179-
if stableRepoCacheNotFoundErr != nil {
180-
wrapper.updateRepos()
177+
_, err = os.Stat(stableRepoCachePathAbs)
178+
if err != nil {
179+
err = wrapper.updateRepos()
180+
if err != nil {
181+
return nil, err
182+
}
181183
}
182184

183185
return wrapper, nil
@@ -222,10 +224,8 @@ func ensureTiller(kubectlClient *kubernetes.Clientset, config *v1.Config, upgrad
222224
defer log.StopWait()
223225

224226
_, err := kubectlClient.CoreV1().ServiceAccounts(tillerSA.Namespace).Get(tillerSA.Name, metav1.GetOptions{})
225-
226227
if err != nil {
227228
_, err := kubectlClient.CoreV1().ServiceAccounts(tillerSA.Namespace).Create(tillerSA)
228-
229229
if err != nil {
230230
return err
231231
}
@@ -244,12 +244,14 @@ func ensureTiller(kubectlClient *kubernetes.Clientset, config *v1.Config, upgrad
244244
Verbs: []string{k8sv1beta1.ResourceAll},
245245
},
246246
})
247-
248247
if err != nil {
249248
return err
250249
}
251250

252-
helminstaller.Install(kubectlClient, tillerOptions)
251+
err = helminstaller.Install(kubectlClient, tillerOptions)
252+
if err != nil {
253+
return err
254+
}
253255

254256
appNamespaces := []*string{
255257
config.DevSpace.Release.Namespace,
@@ -258,15 +260,19 @@ func ensureTiller(kubectlClient *kubernetes.Clientset, config *v1.Config, upgrad
258260
if config.Services.InternalRegistry != nil && config.Services.InternalRegistry.Release.Namespace != nil {
259261
appNamespaces = append(appNamespaces, config.Services.InternalRegistry.Release.Namespace)
260262
}
261-
tillerConfig.AppNamespaces = &appNamespaces
262263

264+
tillerConfig.AppNamespaces = &appNamespaces
263265
for _, appNamespace := range *tillerConfig.AppNamespaces {
264-
err = ensureRoleBinding(kubectlClient, tillerConfig, tillerRoleName, *appNamespace, defaultPolicyRules)
266+
if *appNamespace == tillerRoleManagerName {
267+
continue
268+
}
265269

270+
err = ensureRoleBinding(kubectlClient, tillerConfig, tillerRoleName, *appNamespace, defaultPolicyRules)
266271
if err != nil {
267272
return err
268273
}
269274
}
275+
270276
log.StopWait()
271277
log.Done("Tiller started")
272278

@@ -326,6 +332,7 @@ func addAppNamespaces(appNamespaces *[]*string, namespaces []*string) {
326332
newAppNamespaces = append(newAppNamespaces, ns)
327333
}
328334
}
335+
329336
appNamespaces = &newAppNamespaces
330337
}
331338

@@ -354,32 +361,36 @@ func DeleteTiller(kubectlClient *kubernetes.Clientset, tillerConfig *v1.TillerCo
354361
err := kubectlClient.ExtensionsV1beta1().Deployments(tillerNamespace).Delete(TillerDeploymentName, &metav1.DeleteOptions{
355362
PropagationPolicy: &propagationPolicy,
356363
})
364+
if err != nil {
365+
errs = append(errs, err)
366+
}
357367

368+
err = kubectlClient.CoreV1().Services(tillerNamespace).Delete(TillerDeploymentName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
358369
if err != nil {
359370
errs = append(errs, err)
360371
}
361372

362373
err = kubectlClient.CoreV1().ServiceAccounts(tillerNamespace).Delete(tillerServiceAccountName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
363-
364374
if err != nil {
365375
errs = append(errs, err)
366376
}
367-
roleNamespace := append(*tillerConfig.AppNamespaces, &tillerNamespace)
368377

378+
roleNamespace := append(*tillerConfig.AppNamespaces, &tillerNamespace)
369379
for _, appNamespace := range roleNamespace {
370380
roleName := tillerRoleName
371381

372382
if *appNamespace == tillerNamespace {
373383
roleName = tillerRoleManagerName
374384
}
375-
err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(roleName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
376385

386+
log.Infof("Delete %s RoleName %s", *appNamespace, roleName)
387+
388+
err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(roleName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
377389
if err != nil {
378390
errs = append(errs, err)
379391
}
380392

381393
err = kubectlClient.RbacV1beta1().RoleBindings(*appNamespace).Delete(roleName+"-binding", &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
382-
383394
if err != nil {
384395
errs = append(errs, err)
385396
}
@@ -429,6 +440,8 @@ func ensureRoleBinding(kubectlClient *kubernetes.Clientset, tillerConfig *v1.Til
429440
Name: role.Name,
430441
},
431442
}
443+
444+
// Ignore Errors
432445
kubectlClient.RbacV1beta1().Roles(namespace).Create(role)
433446
kubectlClient.RbacV1beta1().RoleBindings(namespace).Create(rolebinding)
434447

@@ -437,20 +450,21 @@ func ensureRoleBinding(kubectlClient *kubernetes.Clientset, tillerConfig *v1.Til
437450

438451
func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
439452
allRepos, err := repo.LoadRepositoriesFile(helmClientWrapper.Settings.Home.RepositoryFile())
440-
441453
if err != nil {
442454
return err
443455
}
456+
444457
repos := []*repo.ChartRepository{}
445458

446459
for _, repoData := range allRepos.Repositories {
447460
repo, err := repo.NewChartRepository(repoData, getter.All(*helmClientWrapper.Settings))
448-
449461
if err != nil {
450462
return err
451463
}
464+
452465
repos = append(repos, repo)
453466
}
467+
454468
wg := sync.WaitGroup{}
455469

456470
for _, re := range repos {
@@ -460,7 +474,6 @@ func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
460474
defer wg.Done()
461475

462476
err := re.DownloadIndexFile(helmClientWrapper.Settings.Home.String())
463-
464477
if err != nil {
465478
log.With(err).Error("Unable to download repo index")
466479

@@ -476,21 +489,21 @@ func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
476489

477490
// ReleaseExists checks if the given release name exists
478491
func (helmClientWrapper *HelmClientWrapper) ReleaseExists(releaseName string) (bool, error) {
479-
_, releaseHistoryErr := helmClientWrapper.Client.ReleaseHistory(releaseName, k8shelm.WithMaxHistory(1))
480-
481-
if releaseHistoryErr != nil {
482-
if strings.Contains(releaseHistoryErr.Error(), helmstoragedriver.ErrReleaseNotFound(releaseName).Error()) {
492+
_, err := helmClientWrapper.Client.ReleaseHistory(releaseName, k8shelm.WithMaxHistory(1))
493+
if err != nil {
494+
if strings.Contains(err.Error(), helmstoragedriver.ErrReleaseNotFound(releaseName).Error()) {
483495
return false, nil
484496
}
485-
return false, releaseHistoryErr
497+
498+
return false, err
486499
}
500+
487501
return true, nil
488502
}
489503

490504
// InstallChartByPath installs the given chartpath und the releasename in the releasenamespace
491505
func (helmClientWrapper *HelmClientWrapper) InstallChartByPath(releaseName string, releaseNamespace string, chartPath string, values *map[interface{}]interface{}) (*hapi_release5.Release, error) {
492506
chart, err := helmchartutil.Load(chartPath)
493-
494507
if err != nil {
495508
return nil, err
496509
}
@@ -592,11 +605,11 @@ func (helmClientWrapper *HelmClientWrapper) InstallChartByName(releaseName strin
592605
}
593606
os.MkdirAll(helmClientWrapper.Settings.Home.Archive(), os.ModePerm)
594607

595-
chartPath, _, chartDownloadErr := chartDownloader.DownloadTo(chartName, chartVersion, helmClientWrapper.Settings.Home.Archive())
596-
597-
if chartDownloadErr != nil {
598-
return nil, chartDownloadErr
608+
chartPath, _, err := chartDownloader.DownloadTo(chartName, chartVersion, helmClientWrapper.Settings.Home.Archive())
609+
if err != nil {
610+
return nil, err
599611
}
612+
600613
return helmClientWrapper.InstallChartByPath(releaseName, releaseNamespace, chartPath, values)
601614
}
602615

0 commit comments

Comments
 (0)