1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
#include "../include/GlobalLib.hpp"
#include "../include/FileUtil.hpp"
#include "../backend/BackendUtils.hpp"
#include "../backend/ninja/Ninja.hpp"
#include "../include/Conf.hpp"
#include "../include/curl.hpp"
#include "../include/Archive.hpp"
#include "../include/CmakeModule.hpp"
#include "../include/Dependency.hpp"
#include "../include/GitRepository.hpp"
using namespace std;
namespace sibs
{
Result<bool> GlobalLib::validatePackageExists(const FileString &globalLibRootDir, const std::string &name)
{
FileString packageDir = globalLibRootDir + TINYDIR_STRING("/");
#if OS_FAMILY == OS_FAMILY_POSIX
packageDir += name;
#else
packageDir += utf8To16(name);
#endif
FileType packageDirFileType = getFileType(packageDir.c_str());
switch(packageDirFileType)
{
case FileType::FILE_NOT_FOUND:
{
string errMsg = "Global lib dependency not found: ";
errMsg += toUtf8(packageDir);
return Result<bool>::Err(errMsg, DependencyError::DEPENDENCY_NOT_FOUND);
}
case FileType::REGULAR:
{
string errMsg = "Corrupt library directory. ";
errMsg += toUtf8(packageDir);
errMsg += " is a file, expected it to be a directory";
return Result<bool>::Err(errMsg);
}
case FileType::DIRECTORY:
{
return Result<bool>::Ok(true);
}
default:
{
return Result<bool>::Err("Unexpected error!");
}
}
}
Result<bool> GlobalLib::getLibs(const std::vector<PackageListDependency*> &libs, const SibsConfig &parentConfig, const FileString &globalLibRootDir, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
{
for(PackageListDependency *globalLibDependency : libs)
{
printf("Dependency %s is missing from pkg-config, trying global lib\n", globalLibDependency->name.c_str());
Result<bool> globalLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(parentConfig, globalLibRootDir, globalLibDependency->name, globalLibDependency->version, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
if(!globalLibLinkerFlagsResult)
{
if(globalLibLinkerFlagsResult.getErrorCode() == GlobalLib::DependencyError::DEPENDENCY_NOT_FOUND || globalLibLinkerFlagsResult.getErrorCode() == GlobalLib::DependencyError::DEPENDENCY_VERSION_NO_MATCH)
{
printf("Dependency not found in global lib, trying to download from github\n");
// TODO: Download several dependencies at the same time by adding them to a list
// and then iterate them and download them all using several threads.
// All dependecies should be downloaded at the same time, this includes dependencies of dependencies.
// If a dependency is missing, fail build BEFORE downloading dependencies and before compiling anything.
// You do not want to possibly wait several minutes only for build to fail when there is no compilation error.
// TODO: If return error is invalid url, then the message should be converted to
// invalid package name/version. A check should be done if it is the name or version
// that is invalid.
Result<bool> downloadDependencyResult = GlobalLib::downloadDependency(globalLibDependency);
if(!downloadDependencyResult)
return downloadDependencyResult;
globalLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(parentConfig, globalLibRootDir, globalLibDependency->name, globalLibDependency->version, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
if(!globalLibLinkerFlagsResult)
return globalLibLinkerFlagsResult;
}
else
{
return globalLibLinkerFlagsResult;
}
}
}
for(GitDependency *gitDependency : parentConfig.getGitDependencies())
{
Result<bool> gitLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(parentConfig, globalLibRootDir, gitDependency, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
if(!gitLibLinkerFlagsResult)
{
if(gitLibLinkerFlagsResult.getErrorCode() == GlobalLib::DependencyError::DEPENDENCY_NOT_FOUND)
{
printf("Dependency %s not found in global lib, trying to download from git\n", gitDependency->name.c_str());
// TODO: Download several dependencies at the same time by adding them to a list
// and then iterate them and download them all using several threads.
// All dependecies should be downloaded at the same time, this includes dependencies of dependencies.
// If a dependency is missing, fail build BEFORE downloading dependencies and before compiling anything.
// You do not want to possibly wait several minutes only for build to fail when there is no compilation error.
// TODO: If return error is invalid url, then the message should be converted to
// invalid package name/version. A check should be done if it is the name or version
// that is invalid.
Result<bool> downloadDependencyResult = GlobalLib::downloadDependency(gitDependency);
if(!downloadDependencyResult)
return downloadDependencyResult;
gitLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(parentConfig, globalLibRootDir, gitDependency, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
if(!gitLibLinkerFlagsResult)
return gitLibLinkerFlagsResult;
}
else
{
return gitLibLinkerFlagsResult;
}
}
}
return Result<bool>::Ok(true);
}
Result<bool> GlobalLib::getLibsLinkerFlags(const SibsConfig &parentConfig, const FileString &globalLibRootDir, const std::string &name, const std::string &version, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
{
Result<bool> packageExistsResult = validatePackageExists(globalLibRootDir, name);
if (packageExistsResult.isErr())
return packageExistsResult;
#if OS_FAMILY == OS_FAMILY_POSIX
FileString namePlatformNative = name;
FileString versionPlatformNative = version;
#else
FileString namePlatformNative = utf8To16(name);
FileString versionPlatformNative = utf8To16(version);
#endif
FileString packageDir = globalLibRootDir + TINYDIR_STRING("/");
packageDir += namePlatformNative;
// TODO: Instead of checking if version is exact match, check if package has same major version
// and same or newer minor version
FileString foundVersion;
walkDir(packageDir.c_str(), [&foundVersion, &versionPlatformNative](tinydir_file *file)
{
if(file->is_dir)
{
//printf("version: %s\n", file->name);
if(_tinydir_strcmp(versionPlatformNative.c_str(), file->name) == 0)
foundVersion = file->name;
}
});
if(foundVersion.empty())
return Result<bool>::Err("Global lib dependency found, but version doesn't match dependency version", DependencyError::DEPENDENCY_VERSION_NO_MATCH);
packageDir += TINYDIR_STRING("/");
packageDir += versionPlatformNative;
return GlobalLib::getLibsLinkerFlagsCommon(parentConfig, packageDir, name, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
}
Result<bool> GlobalLib::getLibsLinkerFlags(const SibsConfig &parentConfig, const FileString &globalLibRootDir, GitDependency *gitDependency, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
{
Result<bool> packageExistsResult = validatePackageExists(globalLibRootDir, gitDependency->name);
if (packageExistsResult.isErr())
return packageExistsResult;
#if OS_FAMILY == OS_FAMILY_POSIX
FileString namePlatformNative = gitDependency->name;
FileString versionPlatformNative = gitDependency->revision;
#else
FileString namePlatformNative = utf8To16(name);
FileString versionPlatformNative = utf8To16(version);
#endif
FileString packageDir = globalLibRootDir + TINYDIR_STRING("/");
packageDir += namePlatformNative;
packageDir += TINYDIR_STRING("/");
packageDir += versionPlatformNative;
// TODO: Check path is valid git repository by using git_repository_open_ext
// TODO: Pull if revision == HEAD, fail build if there are conflicts.
// TODO: When building a sibs project, put a symlink in libs directory.
// This allows you to have dependency on a project and make changes to it without pushing
// to remote before the dependant project can see the changes.
//GitRepository gitRepo;
//gitRepo.pull(gitDependency, packageDir);
return GlobalLib::getLibsLinkerFlagsCommon(parentConfig, packageDir, gitDependency->name, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
}
Result<bool> GlobalLib::getLibsLinkerFlagsCommon(const SibsConfig &parentConfig, const FileString &packageDir, const string &dependencyName, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
{
FileString projectConfFilePath = packageDir;
projectConfFilePath += TINYDIR_STRING("/project.conf");
FileType projectConfFileType = getFileType(projectConfFilePath.c_str());
if(projectConfFileType != FileType::REGULAR)
{
string errMsg = "Dependency not found: ";
errMsg += toUtf8(packageDir);
return Result<bool>::Err(errMsg, DependencyError::DEPENDENCY_NOT_FOUND);
}
SibsConfig sibsConfig(parentConfig.getCompiler(), packageDir, parentConfig.getOptimizationLevel(), false);
Result<bool> result = Config::readFromFile(projectConfFilePath.c_str(), sibsConfig);
if (result.isErr())
return result;
if(sibsConfig.getPackageName().empty())
return Result<bool>::Err("project.conf is missing required field package.name");
if(sibsConfig.getPackageType() == PackageType::EXECUTABLE)
{
string errMsg = "The dependency ";
errMsg += dependencyName;
errMsg += " is an executable. Only libraries can be dependencies";
return Result<bool>::Err(errMsg);
}
if (!containsPlatform(sibsConfig.getPlatforms(), SYSTEM_PLATFORM))
{
string errMsg = "The dependency ";
errMsg += dependencyName;
errMsg += " does not support your platform (";
errMsg += asString(SYSTEM_PLATFORM);
errMsg += ")";
return Result<bool>::Err(errMsg);
}
FileString buildPath = packageDir + TINYDIR_STRING("/sibs-build/");
switch (sibsConfig.getOptimizationLevel())
{
case OPT_LEV_DEBUG:
{
buildPath += TINYDIR_STRING("debug");
// TODO: Check if this dependency is static or dynamic and decide which lib path to use from that
for(const string &staticLib : sibsConfig.getDebugStaticLibs())
{
string staticLibCmd = "\"";
staticLibCmd += staticLib;
staticLibCmd += "\"";
staticLinkerFlagCallbackFunc(staticLibCmd);
}
break;
}
case OPT_LEV_RELEASE:
{
buildPath += TINYDIR_STRING("release");
// TODO: Check if this dependency is static or dynamic and decide which lib path to use from that
for (const string &staticLib : sibsConfig.getReleaseStaticLibs())
{
string staticLibCmd = "\"";
staticLibCmd += staticLib;
staticLibCmd += "\"";
staticLinkerFlagCallbackFunc(staticLibCmd);
}
break;
}
}
if(sibsConfig.shouldUseCmake())
{
CmakeModule cmakeModule;
return cmakeModule.compile(sibsConfig, buildPath, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
}
else
{
backend::Ninja ninja;
backend::BackendUtils::collectSourceFiles(packageDir.c_str(), &ninja, sibsConfig);
return ninja.build(sibsConfig, buildPath.c_str(), staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
}
}
Result<bool> GlobalLib::downloadDependency(PackageListDependency *dependency)
{
Result<string> packageUrlResult = Package::getPackageUrl(dependency->name.c_str(), dependency->version.c_str(), SYSTEM_PLATFORM_NAME);
if(!packageUrlResult)
return Result<bool>::Err(packageUrlResult);
const string &url = packageUrlResult.unwrap();
Result<FileString> libPathResult = getHomeDir();
if (!libPathResult)
return Result<bool>::Err(libPathResult);
FileString libPath = libPathResult.unwrap();
libPath += TINYDIR_STRING("/.cache/sibs/lib/");
libPath += toFileString(dependency->name);
libPath += TINYDIR_STRING("/");
libPath += toFileString(dependency->version);
FileString libArchivedFilePath = libPathResult.unwrap();
libArchivedFilePath += TINYDIR_STRING("/.cache/sibs/archive/");
libArchivedFilePath += toFileString(dependency->name);
Result<bool> createArchiveDirResult = createDirectoryRecursive(libArchivedFilePath.c_str());
if(!createArchiveDirResult)
return createArchiveDirResult;
libArchivedFilePath += TINYDIR_STRING("/");
libArchivedFilePath += toFileString(dependency->version);
Result<bool> downloadResult = curl::downloadFile(url.c_str(), libArchivedFilePath.c_str());
if(!downloadResult)
return downloadResult;
// Create build path. This is done here because we dont want to create it if download fails
Result<bool> createLibDirResult = createDirectoryRecursive(libPath.c_str());
if(!createLibDirResult)
return createLibDirResult;
Result<bool> archiveExtractResult = Archive::extract(libArchivedFilePath.c_str(), libPath.c_str());
// We have extracted the archive, we dont need to cache it. If remove fails, it doesn't really matter, user can remove it himself
remove(libArchivedFilePath.c_str());
return archiveExtractResult;
}
Result<bool> GlobalLib::downloadDependency(GitDependency *dependency)
{
Result<FileString> libPathResult = getHomeDir();
if (!libPathResult)
return Result<bool>::Err(libPathResult);
FileString libPath = libPathResult.unwrap();
libPath += TINYDIR_STRING("/.cache/sibs/lib/");
libPath += toFileString(dependency->name);
// We dont care if the directory already exists. Nothing will happen if it does
Result<bool> createLibDirResult = createDirectoryRecursive(libPath.c_str());
if(!createLibDirResult)
return createLibDirResult;
libPath += TINYDIR_STRING("/");
libPath += toFileString(dependency->revision);
GitRepository gitRepo;
return gitRepo.clone(dependency, libPath);
}
}
|