Skip to content

Commit 5906bab

Browse files
FabianKrammFabianKramm
authored
Merge pull request #213 from covexo/mac-issues
Resolve #208, #207, #206, #203
2 parents 5af8a34 + ba136c8 commit 5906bab

8 files changed

Lines changed: 131 additions & 97 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: 57 additions & 42 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,33 +361,39 @@ 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 && strings.HasSuffix(err.Error(), "not found") == false {
365+
errs = append(errs, err)
366+
}
357367

358-
if err != nil {
368+
err = kubectlClient.CoreV1().Services(tillerNamespace).Delete(TillerDeploymentName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
369+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
359370
errs = append(errs, err)
360371
}
361372

362373
err = kubectlClient.CoreV1().ServiceAccounts(tillerNamespace).Delete(tillerServiceAccountName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
363-
364-
if err != nil {
374+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
365375
errs = append(errs, err)
366376
}
367-
roleNamespace := append(*tillerConfig.AppNamespaces, &tillerNamespace)
368377

378+
roleNamespace := append(*tillerConfig.AppNamespaces, &tillerNamespace)
369379
for _, appNamespace := range roleNamespace {
370-
roleName := tillerRoleName
371-
372-
if *appNamespace == tillerNamespace {
373-
roleName = tillerRoleManagerName
380+
err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(tillerRoleName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
381+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
382+
errs = append(errs, err)
374383
}
375-
err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(roleName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
376384

377-
if err != nil {
385+
err = kubectlClient.RbacV1beta1().RoleBindings(*appNamespace).Delete(tillerRoleName+"-binding", &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
386+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
378387
errs = append(errs, err)
379388
}
380389

381-
err = kubectlClient.RbacV1beta1().RoleBindings(*appNamespace).Delete(roleName+"-binding", &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
390+
err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(tillerRoleManagerName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
391+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
392+
errs = append(errs, err)
393+
}
382394

383-
if err != nil {
395+
err = kubectlClient.RbacV1beta1().RoleBindings(*appNamespace).Delete(tillerRoleManagerName+"-binding", &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
396+
if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
384397
errs = append(errs, err)
385398
}
386399
}
@@ -429,6 +442,8 @@ func ensureRoleBinding(kubectlClient *kubernetes.Clientset, tillerConfig *v1.Til
429442
Name: role.Name,
430443
},
431444
}
445+
446+
// Ignore Errors
432447
kubectlClient.RbacV1beta1().Roles(namespace).Create(role)
433448
kubectlClient.RbacV1beta1().RoleBindings(namespace).Create(rolebinding)
434449

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

438453
func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
439454
allRepos, err := repo.LoadRepositoriesFile(helmClientWrapper.Settings.Home.RepositoryFile())
440-
441455
if err != nil {
442456
return err
443457
}
458+
444459
repos := []*repo.ChartRepository{}
445460

446461
for _, repoData := range allRepos.Repositories {
447462
repo, err := repo.NewChartRepository(repoData, getter.All(*helmClientWrapper.Settings))
448-
449463
if err != nil {
450464
return err
451465
}
466+
452467
repos = append(repos, repo)
453468
}
469+
454470
wg := sync.WaitGroup{}
455471

456472
for _, re := range repos {
@@ -460,7 +476,6 @@ func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
460476
defer wg.Done()
461477

462478
err := re.DownloadIndexFile(helmClientWrapper.Settings.Home.String())
463-
464479
if err != nil {
465480
log.With(err).Error("Unable to download repo index")
466481

@@ -476,21 +491,21 @@ func (helmClientWrapper *HelmClientWrapper) updateRepos() error {
476491

477492
// ReleaseExists checks if the given release name exists
478493
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()) {
494+
_, err := helmClientWrapper.Client.ReleaseHistory(releaseName, k8shelm.WithMaxHistory(1))
495+
if err != nil {
496+
if strings.Contains(err.Error(), helmstoragedriver.ErrReleaseNotFound(releaseName).Error()) {
483497
return false, nil
484498
}
485-
return false, releaseHistoryErr
499+
500+
return false, err
486501
}
502+
487503
return true, nil
488504
}
489505

490506
// InstallChartByPath installs the given chartpath und the releasename in the releasenamespace
491507
func (helmClientWrapper *HelmClientWrapper) InstallChartByPath(releaseName string, releaseNamespace string, chartPath string, values *map[interface{}]interface{}) (*hapi_release5.Release, error) {
492508
chart, err := helmchartutil.Load(chartPath)
493-
494509
if err != nil {
495510
return nil, err
496511
}
@@ -592,11 +607,11 @@ func (helmClientWrapper *HelmClientWrapper) InstallChartByName(releaseName strin
592607
}
593608
os.MkdirAll(helmClientWrapper.Settings.Home.Archive(), os.ModePerm)
594609

595-
chartPath, _, chartDownloadErr := chartDownloader.DownloadTo(chartName, chartVersion, helmClientWrapper.Settings.Home.Archive())
596-
597-
if chartDownloadErr != nil {
598-
return nil, chartDownloadErr
610+
chartPath, _, err := chartDownloader.DownloadTo(chartName, chartVersion, helmClientWrapper.Settings.Home.Archive())
611+
if err != nil {
612+
return nil, err
599613
}
614+
600615
return helmClientWrapper.InstallChartByPath(releaseName, releaseNamespace, chartPath, values)
601616
}
602617

0 commit comments

Comments
 (0)