Added Copyright header.
[src/xds/xds-server.git] / 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 }