FilesExpand file tree

 master

/

push.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

252 lines (220 loc) · 6.56 KB

 master

/

push.c

Copy path

Top

File metadata and controls

• Code
• Blame

252 lines (220 loc) · 6.56 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

/*

* "git push"

*/

#include "cache.h"

#include "refs.h"

#include "run-command.h"

#include "builtin.h"

#include "remote.h"

#include "transport.h"

#include "parse-options.h"

static const char * const push_usage[] = {

"git push [<options>] [<repository> [<refspec>...]]",

NULL,

};

static int thin;

static int deleterefs;

static const char *receivepack;

static int verbosity;

static int progress;

static const char **refspec;

static int refspec_nr;

static int refspec_alloc;

static void add_refspec(const char *ref)

{

refspec_nr++;

ALLOC_GROW(refspec, refspec_nr, refspec_alloc);

refspec[refspec_nr-1] = ref;

}

static void set_refspecs(const char **refs, int nr)

{

int i;

for (i = 0; i < nr; i++) {

const char *ref = refs[i];

if (!strcmp("tag", ref)) {

char *tag;

int len;

if (nr <= ++i)

die("tag shorthand without <tag>");

len = strlen(refs[i]) + 11;

if (deleterefs) {

tag = xmalloc(len+1);

strcpy(tag, ":refs/tags/");

} else {

tag = xmalloc(len);

strcpy(tag, "refs/tags/");

}

strcat(tag, refs[i]);

ref = tag;

} else if (deleterefs && !strchr(ref, ':')) {

char *delref;

int len = strlen(ref)+1;

delref = xmalloc(len+1);

strcpy(delref, ":");

strcat(delref, ref);

ref = delref;

} else if (deleterefs)

die("--delete only accepts plain target ref names");

add_refspec(ref);

}

}

static void setup_push_tracking(void)

{

struct strbuf refspec = STRBUF_INIT;

struct branch *branch = branch_get(NULL);

if (!branch)

die("You are not currently on a branch.");

if (!branch->merge_nr || !branch->merge)

die("The current branch %s is not tracking anything.",

branch->name);

if (branch->merge_nr != 1)

die("The current branch %s is tracking multiple branches, "

"refusing to push.", branch->name);

strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);

add_refspec(refspec.buf);

}

static void setup_default_push_refspecs(void)

{

switch (push_default) {

default:

case PUSH_DEFAULT_MATCHING:

add_refspec(":");

break;

case PUSH_DEFAULT_TRACKING:

setup_push_tracking();

break;

case PUSH_DEFAULT_CURRENT:

add_refspec("HEAD");

break;

case PUSH_DEFAULT_NOTHING:

die("You didn't specify any refspecs to push, and "

"push.default is \"nothing\".");

break;

}

}

static int push_with_options(struct transport *transport, int flags)

{

int err;

int nonfastforward;

transport_set_verbosity(transport, verbosity, progress);

if (receivepack)

transport_set_option(transport,

TRANS_OPT_RECEIVEPACK, receivepack);

if (thin)

transport_set_option(transport, TRANS_OPT_THIN, "yes");

if (verbosity > 0)

fprintf(stderr, "Pushing to %s\n", transport->url);

err = transport_push(transport, refspec_nr, refspec, flags,

&nonfastforward);

if (err != 0)

error("failed to push some refs to '%s'", transport->url);

err |= transport_disconnect(transport);

if (!err)

return 0;

if (nonfastforward && advice_push_nonfastforward) {

fprintf(stderr, "To prevent you from losing history, non-fast-forward updates were rejected\n"

"Merge the remote changes (e.g. 'git pull') before pushing again. See the\n"

"'Note about fast-forwards' section of 'git push --help' for details.\n");

}

return 1;

}

static int do_push(const char *repo, int flags)

{

int i, errs;

struct remote *remote = remote_get(repo);

const char **url;

int url_nr;

if (!remote) {

if (repo)

die("bad repository '%s'", repo);

die("No destination configured to push to.");

}

if (remote->mirror)

flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);

if ((flags & TRANSPORT_PUSH_ALL) && refspec) {

if (!strcmp(*refspec, "refs/tags/*"))

return error("--all and --tags are incompatible");

return error("--all can't be combined with refspecs");

}

if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {

if (!strcmp(*refspec, "refs/tags/*"))

return error("--mirror and --tags are incompatible");

return error("--mirror can't be combined with refspecs");

}

if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==

(TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {

return error("--all and --mirror are incompatible");

}

if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {

if (remote->push_refspec_nr) {

refspec = remote->push_refspec;

refspec_nr = remote->push_refspec_nr;

} else if (!(flags & TRANSPORT_PUSH_MIRROR))

setup_default_push_refspecs();

}

errs = 0;

if (remote->pushurl_nr) {

url = remote->pushurl;

url_nr = remote->pushurl_nr;

} else {

url = remote->url;

url_nr = remote->url_nr;

}

if (url_nr) {

for (i = 0; i < url_nr; i++) {

struct transport *transport =

transport_get(remote, url[i]);

if (push_with_options(transport, flags))

errs++;

}

} else {

struct transport *transport =

transport_get(remote, NULL);

if (push_with_options(transport, flags))

errs++;

}

return !!errs;

}

int cmd_push(int argc, const char **argv, const char *prefix)

{

int flags = 0;

int tags = 0;

int rc;

const char *repo = NULL; /* default repository */

struct option options[] = {

OPT__VERBOSITY(&verbosity),

OPT_STRING( 0 , "repo", &repo, "repository", "repository"),

OPT_BIT( 0 , "all", &flags, "push all refs", TRANSPORT_PUSH_ALL),

OPT_BIT( 0 , "mirror", &flags, "mirror all refs",

(TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),

OPT_BOOLEAN( 0, "delete", &deleterefs, "delete refs"),

OPT_BOOLEAN( 0 , "tags", &tags, "push tags (can't be used with --all or --mirror)"),

OPT_BIT('n' , "dry-run", &flags, "dry run", TRANSPORT_PUSH_DRY_RUN),

OPT_BIT( 0, "porcelain", &flags, "machine-readable output", TRANSPORT_PUSH_PORCELAIN),

OPT_BIT('f', "force", &flags, "force updates", TRANSPORT_PUSH_FORCE),

OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),

OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),

OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),

OPT_BIT('u', "set-upstream", &flags, "set upstream for git pull/status",

TRANSPORT_PUSH_SET_UPSTREAM),

OPT_BOOLEAN(0, "progress", &progress, "force progress reporting"),

OPT_END()

};

git_config(git_default_config, NULL);

argc = parse_options(argc, argv, prefix, options, push_usage, 0);

if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))

die("--delete is incompatible with --all, --mirror and --tags");

if (deleterefs && argc < 2)

die("--delete doesn't make sense without any refs");

if (tags)

add_refspec("refs/tags/*");

if (argc > 0) {

repo = argv[0];

set_refspecs(argv + 1, argc - 1);

}

rc = do_push(repo, flags);

if (rc == -1)

usage_with_options(push_usage, options);

else

return rc;

}