lib/xdsserver/sdks.go

   1 /*
   2  * Copyright (C) 2017 "IoT.bzh"
   3  * Author Sebastien Douheret <sebastien@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package xdsserver
  19
  20 import (
  21         "fmt"
  22         "path"
  23         "path/filepath"
  24         "strings"
  25         "sync"
  26
  27         common "github.com/iotbzh/xds-common/golib"
  28         "github.com/iotbzh/xds-server/lib/xsapiv1"
  29 )
  30
  31 // SDKs List of installed SDK
  32 type SDKs struct {
  33         *Context
  34         Sdks map[string]*CrossSDK
  35
  36         mutex sync.Mutex
  37 }
  38
  39 // NewSDKs creates a new instance of SDKs
  40 func NewSDKs(ctx *Context) (*SDKs, error) {
  41         s := SDKs{
  42                 Context: ctx,
  43                 Sdks:    make(map[string]*CrossSDK),
  44         }
  45
  46         // Retrieve installed sdks
  47         sdkRD := ctx.Config.FileConf.SdkRootDir
  48
  49         if common.Exists(sdkRD) {
  50
  51                 // Assume that SDK install tree is <rootdir>/<profile>/<version>/<arch>
  52                 dirs, err := filepath.Glob(path.Join(sdkRD, "*", "*", "*"))
  53                 if err != nil {
  54                         ctx.Log.Debugf("Error while retrieving SDKs: dir=%s, error=%s", sdkRD, err.Error())
  55                         return &s, err
  56                 }
  57                 s.mutex.Lock()
  58                 defer s.mutex.Unlock()
  59
  60                 for _, d := range dirs {
  61                         if !common.IsDir(d) {
  62                                 continue
  63                         }
  64                         cSdk, err := NewCrossSDK(d)
  65                         if err != nil {
  66                                 ctx.Log.Debugf("Error while processing SDK dir=%s, err=%s", d, err.Error())
  67                                 continue
  68                         }
  69                         s.Sdks[cSdk.sdk.ID] = cSdk
  70                 }
  71         }
  72
  73         ctx.Log.Debugf("SDKs: %d cross sdks found", len(s.Sdks))
  74
  75         return &s, nil
  76 }
  77
  78 // ResolveID Complete an SDK ID (helper for user that can use partial ID value)
  79 func (s *SDKs) ResolveID(id string) (string, error) {
  80         if id == "" {
  81                 return "", nil
  82         }
  83
  84         match := []string{}
  85         for iid := range s.Sdks {
  86                 if strings.HasPrefix(iid, id) {
  87                         match = append(match, iid)
  88                 }
  89         }
  90
  91         if len(match) == 1 {
  92                 return match[0], nil
  93         } else if len(match) == 0 {
  94                 return id, fmt.Errorf("Unknown sdk id")
  95         }
  96         return id, fmt.Errorf("Multiple sdk IDs found with provided prefix: " + id)
  97 }
  98
  99 // Get returns an SDK from id
 100 func (s *SDKs) Get(id string) *xsapiv1.SDK {
 101         s.mutex.Lock()
 102         defer s.mutex.Unlock()
 103
 104         sc, exist := s.Sdks[id]
 105         if !exist {
 106                 return nil
 107         }
 108         return (*sc).Get()
 109 }
 110
 111 // GetAll returns all existing SDKs
 112 func (s *SDKs) GetAll() []xsapiv1.SDK {
 113         s.mutex.Lock()
 114         defer s.mutex.Unlock()
 115         res := []xsapiv1.SDK{}
 116         for _, v := range s.Sdks {
 117                 res = append(res, *(*v).Get())
 118         }
 119         return res
 120 }
 121
 122 // GetEnvCmd returns the command used to initialized the environment for an SDK
 123 func (s *SDKs) GetEnvCmd(id string, defaultID string) []string {
 124         if id == "" && defaultID == "" {
 125                 // no env cmd
 126                 return []string{}
 127         }
 128
 129         s.mutex.Lock()
 130         defer s.mutex.Unlock()
 131
 132         if iid, err := s.ResolveID(id); err == nil {
 133                 if sdk, exist := s.Sdks[iid]; exist {
 134                         return sdk.GetEnvCmd()
 135                 }
 136         }
 137
 138         if sdk, exist := s.Sdks[defaultID]; defaultID != "" && exist {
 139                 return sdk.GetEnvCmd()
 140         }
 141
 142         // Return default env that may be empty
 143         return []string{}
 144 }